@lugg/maps 1.0.0-beta.9 → 1.0.0

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

@@ -5,6 +5,7 @@ import android.content.ComponentCallbacks2
 import android.content.Context
 import android.content.res.Configuration
 import android.view.View
+import android.view.ViewTreeObserver
 import android.widget.ImageView
 import androidx.core.graphics.createBitmap
 import androidx.core.view.ViewCompat
@@ -15,9 +16,8 @@ import com.google.android.gms.maps.GoogleMap
 import com.google.android.gms.maps.GoogleMapOptions
 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.CameraPosition
 import com.google.android.gms.maps.model.Circle
 import com.google.android.gms.maps.model.CircleOptions
 import com.google.android.gms.maps.model.GroundOverlay
@@ -26,6 +26,7 @@ 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.MarkerOptions
 import com.google.android.gms.maps.model.Polygon
 import com.google.android.gms.maps.model.PolygonOptions
 import com.google.android.gms.maps.model.PolylineOptions
@@ -48,7 +49,10 @@ import com.luggmaps.LuggTileOverlayViewDelegate
 import com.luggmaps.extensions.findViewByTag
 import java.net.URL
 import kotlin.math.atan
+import kotlin.math.ln
+import kotlin.math.log2
 import kotlin.math.pow
+import kotlin.math.sin
 import kotlin.math.sinh
 
 class GoogleMapProvider(private val context: Context) :
@@ -78,6 +82,10 @@ class GoogleMapProvider(private val context: Context) :
 
   var mapId: String = DEMO_MAP_ID
 
+  // Renders a non-interactive static map — lite mode when the view fits
+  // the lite bitmap cap, a gesture-less full map otherwise. Creation-time only.
+  var staticMode: Boolean = false
+
   private var wrapperView: LuggMapWrapperView? = null
   private var currentNightMode: Int = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
   private var mapView: MapView? = null
@@ -96,6 +104,7 @@ class GoogleMapProvider(private val context: Context) :
   private val groundOverlayToViewMap = mutableMapOf<GroundOverlay, LuggGroundOverlayView>()
   private val markerToViewMap = mutableMapOf<Marker, LuggMarkerView>()
   private val liveMarkerViews = mutableSetOf<LuggMarkerView>()
+  private var staticProjectionReady = false
   private var activeNonBubbledMarker: Marker? = null
   private var tapLocation: LatLng? = null
 
@@ -109,6 +118,7 @@ class GoogleMapProvider(private val context: Context) :
   private var scrollEnabled: Boolean = true
   private var rotateEnabled: Boolean = true
   private var pitchEnabled: Boolean = true
+  private var compassEnabled: Boolean = true
   private var userLocationEnabled: Boolean = false
   private var userLocationButtonEnabled: Boolean = false
 
@@ -126,6 +136,13 @@ class GoogleMapProvider(private val context: Context) :
   private var insetAdjustment: String = "never"
   private var systemInsets: EdgeInsets = EdgeInsets()
 
+  // The maps renderer adds and positions the watermark asynchronously; the
+  // layout listener re-evaluates the translation on every layout pass
+  private var watermarkLayoutListener: ViewTreeObserver.OnGlobalLayoutListener? = null
+  private var watermarkView: View? = null
+  private var watermarkTargetX = 0f
+  private var watermarkTargetY = 0f
+
   // region MapProvider
 
   override fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float) {
@@ -136,21 +153,45 @@ class GoogleMapProvider(private val context: Context) :
     initialZoom = zoom
 
     val wrapper = wrapperView as LuggMapWrapperView
+    wrapper.relayoutChildOnRequest = staticMode
     this.wrapperView = wrapper
 
     context.applicationContext.registerComponentCallbacks(this)
 
-    val options = GoogleMapOptions().mapId(mapId)
+    // Static mode needs the view size to pick lite vs full map, so wait
+    // for the first layout if it hasn't happened yet
+    if (staticMode && (wrapper.width == 0 || wrapper.height == 0)) {
+      wrapper.onLayoutReady = { createMapView() }
+    } else {
+      createMapView()
+    }
+  }
+
+  private fun createMapView() {
+    if (mapView != null) return
+    val wrapper = wrapperView ?: return
+
+    // Lite mode renders the map as a single bitmap capped at ~2048px per
+    // dimension, centered in the view — bigger views get letterboxed. Fall
+    // back to a full map (gestures disabled) when the view exceeds the cap
+    val useLite = staticMode && maxOf(wrapper.width, wrapper.height) <= LITE_MODE_MAX_SIZE
+    val options = GoogleMapOptions().liteMode(useLite)
+    // Lite mode doesn't support map IDs (cloud-based styling); setting one
+    // makes the static map render blank
+    if (!useLite) options.mapId(mapId)
     mapView = MapView(context, options).also { view ->
       view.onCreate(null)
       view.onResume()
       view.getMapAsync(this)
       wrapper.addView(view)
     }
+    wrapper.onLayoutReady = null
   }
 
   override fun destroy() {
+    wrapperView?.onLayoutReady = null
     detachWindowInsetsListener()
+    detachWatermarkLayoutListener()
     context.applicationContext.unregisterComponentCallbacks(this)
     dismissNonBubbledCallout()
     for (markerView in liveMarkerViews) {
@@ -194,7 +235,23 @@ class GoogleMapProvider(private val context: Context) :
     googleMap = map
     _isMapReady = true
 
-    val position = LatLng(initialLatitude, initialLongitude)
+    if (staticMode) {
+      // Tapping the map otherwise shows an "open in Google Maps" toolbar
+      map.uiSettings.isMapToolbarEnabled = false
+      // The projection is only valid once the map has rendered, and no
+      // camera events fire afterwards to correct live marker positions
+      map.setOnMapLoadedCallback {
+        staticProjectionReady = true
+        positionLiveMarkers()
+      }
+    }
+
+    // Padding must be in place before the initial camera move: setPadding
+    // never repositions the current camera, but camera updates after it are
+    // relative to the padded center
+    applyEdgeInsets()
+
+    val position = if (staticMode) staticCameraTarget() else LatLng(initialLatitude, initialLongitude)
     map.moveCamera(CameraUpdateFactory.newLatLngZoom(position, initialZoom))
 
     map.setOnCameraMoveStartedListener(this)
@@ -217,7 +274,6 @@ class GoogleMapProvider(private val context: Context) :
 
     applyUiSettings()
     applyZoomLimits()
-    applyEdgeInsets()
     applyInsetAdjustment()
     applyTheme()
     applyUserLocation()
@@ -441,24 +497,33 @@ class GoogleMapProvider(private val context: Context) :
 
   override fun setZoomEnabled(enabled: Boolean) {
     zoomEnabled = enabled
+    if (staticMode) return
     googleMap?.uiSettings?.isZoomGesturesEnabled = enabled
   }
 
   override fun setScrollEnabled(enabled: Boolean) {
     scrollEnabled = enabled
+    if (staticMode) return
     googleMap?.uiSettings?.isScrollGesturesEnabled = enabled
   }
 
   override fun setRotateEnabled(enabled: Boolean) {
     rotateEnabled = enabled
+    if (staticMode) return
     googleMap?.uiSettings?.isRotateGesturesEnabled = enabled
   }
 
   override fun setPitchEnabled(enabled: Boolean) {
     pitchEnabled = enabled
+    if (staticMode) return
     googleMap?.uiSettings?.isTiltGesturesEnabled = enabled
   }
 
+  override fun setCompassEnabled(enabled: Boolean) {
+    compassEnabled = enabled
+    googleMap?.uiSettings?.isCompassEnabled = enabled
+  }
+
   @SuppressLint("MissingPermission")
   override fun setUserLocationEnabled(enabled: Boolean) {
     userLocationEnabled = enabled
@@ -505,6 +570,11 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun setEdgeInsets(edgeInsets: EdgeInsets) {
+    if (staticMode) {
+      setStaticEdgeInsets(edgeInsets)
+      return
+    }
+
     val oldInsets = this.edgeInsets
     this.edgeInsets = edgeInsets
     applyEdgeInsets()
@@ -518,6 +588,11 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun setEdgeInsets(edgeInsets: EdgeInsets, duration: Int) {
+    if (staticMode) {
+      setStaticEdgeInsets(edgeInsets)
+      return
+    }
+
     val map = googleMap
     val oldInsets = this.edgeInsets
     this.edgeInsets = edgeInsets
@@ -599,6 +674,10 @@ class GoogleMapProvider(private val context: Context) :
     syncPolylineView(polylineView)
   }
 
+  override fun polylineViewDidDrop(polylineView: LuggPolylineView) {
+    teardownPolyline(polylineView)
+  }
+
   // endregion
 
   // region PolygonViewDelegate
@@ -692,12 +771,12 @@ class GoogleMapProvider(private val context: Context) :
     val map = googleMap ?: return
 
     val position = LatLng(markerView.latitude, markerView.longitude)
-    val options = AdvancedMarkerOptions()
+    val options = MarkerOptions()
       .position(position)
       .title(markerView.title)
       .snippet(markerView.description)
 
-    val marker = map.addMarker(options) as AdvancedMarker
+    val marker = map.addMarker(options) ?: return
     marker.setAnchor(markerView.anchorX, markerView.anchorY)
     marker.zIndex = markerView.zIndex
     marker.rotation = markerView.rotate
@@ -715,9 +794,8 @@ class GoogleMapProvider(private val context: Context) :
     }
   }
 
-  // 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.
+  // Live marker: content view is added to the wrapper and positioned via screen projection.
+  // 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
 
@@ -728,6 +806,10 @@ class GoogleMapProvider(private val context: Context) :
 
     val contentView = markerView.contentView
     contentView.pointerEvents = com.facebook.react.uimanager.PointerEvents.NONE
+    // Until the lite map's projection is valid, hide the marker instead of
+    // flashing it at a wrong position; onMapLoaded positions and shows it
+    contentView.visibility =
+      if (staticMode && !staticProjectionReady) View.INVISIBLE else View.VISIBLE
     (contentView.parent as? android.view.ViewGroup)?.removeView(contentView)
     wrapper.addView(contentView)
     liveMarkerViews.add(markerView)
@@ -759,10 +841,12 @@ class GoogleMapProvider(private val context: Context) :
 
   private fun positionLiveMarker(markerView: LuggMarkerView) {
     val map = googleMap ?: return
+    if (staticMode && !staticProjectionReady) 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
+    contentView.visibility = View.VISIBLE
   }
 
   // endregion
@@ -775,8 +859,12 @@ class GoogleMapProvider(private val context: Context) :
   }
 
   override fun removePolylineView(polylineView: LuggPolylineView) {
-    polylineAnimators[polylineView]?.destroy()
-    polylineAnimators.remove(polylineView)
+    teardownPolyline(polylineView)
+  }
+
+  private fun teardownPolyline(polylineView: LuggPolylineView) {
+    pendingPolylineViews.remove(polylineView)
+    polylineAnimators.remove(polylineView)?.destroy()
     polylineView.polyline?.remove()
     polylineView.polyline = null
   }
@@ -792,15 +880,13 @@ class GoogleMapProvider(private val context: Context) :
       return
     }
 
-    polylineView.polyline?.width = polylineView.strokeWidth.dpToPx()
-    polylineView.polyline?.zIndex = polylineView.zIndex
-
     polylineAnimators[polylineView]?.apply {
       coordinates = polylineView.coordinates
       strokeColors = polylineView.strokeColors
       strokeWidth = polylineView.strokeWidth.dpToPx()
+      zIndex = polylineView.zIndex
       animatedOptions = polylineView.animatedOptions
-      animated = polylineView.animated
+      animated = polylineView.animated && !staticMode
       update()
     }
   }
@@ -814,6 +900,8 @@ class GoogleMapProvider(private val context: Context) :
   private fun addPolylineViewToMap(polylineView: LuggPolylineView) {
     val map = googleMap ?: return
 
+    polylineAnimators.remove(polylineView)?.destroy()
+
     val options = PolylineOptions()
       .width(polylineView.strokeWidth.dpToPx())
       .zIndex(polylineView.zIndex)
@@ -826,8 +914,10 @@ class GoogleMapProvider(private val context: Context) :
       coordinates = polylineView.coordinates
       strokeColors = polylineView.strokeColors
       strokeWidth = polylineView.strokeWidth.dpToPx()
+      zIndex = polylineView.zIndex
       animatedOptions = polylineView.animatedOptions
-      animated = polylineView.animated
+      // Static maps render once; show the full polyline instead of animating
+      animated = polylineView.animated && !staticMode
       update()
     }
 
@@ -1126,10 +1216,25 @@ class GoogleMapProvider(private val context: Context) :
   // region Commands
 
   override fun moveCamera(latitude: Double, longitude: Double, zoom: Double, duration: Int) {
+    if (staticMode) {
+      // Static maps don't animate; re-center at the final camera
+      initialLatitude = latitude
+      initialLongitude = longitude
+      if (zoom > 0) initialZoom = zoom.toFloat()
+      val map = googleMap ?: return
+      map.moveCamera(CameraUpdateFactory.newLatLngZoom(staticCameraTarget(), initialZoom))
+      positionLiveMarkers()
+      return
+    }
+
     val map = googleMap ?: return
     val position = LatLng(latitude, longitude)
     val targetZoom = if (zoom > 0) zoom.toFloat() else map.cameraPosition.zoom
-    val cameraUpdate = CameraUpdateFactory.newLatLngZoom(position, targetZoom)
+    val cameraPosition = CameraPosition.Builder(map.cameraPosition)
+      .target(position)
+      .zoom(targetZoom)
+      .build()
+    val cameraUpdate = CameraUpdateFactory.newCameraPosition(cameraPosition)
     when {
       duration < 0 -> map.animateCamera(cameraUpdate)
       duration > 0 -> map.animateCamera(cameraUpdate, duration, null)
@@ -1151,15 +1256,20 @@ class GoogleMapProvider(private val context: Context) :
     val latLongs = coordinates.filterIsInstance<LatLng>()
     if (latLongs.isEmpty()) return
 
-    val boundsBuilder = LatLngBounds.Builder()
-    latLongs.forEach { boundsBuilder.include(it) }
-    val bounds = boundsBuilder.build()
-
     val top = edgeInsetsTop.toFloat().dpToPx().toInt()
     val left = edgeInsetsLeft.toFloat().dpToPx().toInt()
     val bottom = edgeInsetsBottom.toFloat().dpToPx().toInt()
     val right = edgeInsetsRight.toFloat().dpToPx().toInt()
 
+    if (staticMode) {
+      fitStaticCoordinates(latLongs, top, left, bottom, right)
+      return
+    }
+
+    val boundsBuilder = LatLngBounds.Builder()
+    latLongs.forEach { boundsBuilder.include(it) }
+    val bounds = boundsBuilder.build()
+
     val combined = combinedEdgeInsets()
     map.setPadding(
       combined.left + left,
@@ -1185,10 +1295,17 @@ class GoogleMapProvider(private val context: Context) :
 
   private fun applyUiSettings() {
     googleMap?.uiSettings?.apply {
+      if (staticMode) {
+        // The non-lite fallback is a full map; keep it behaving like a
+        // static image (lite mode ignores gestures anyway)
+        setAllGesturesEnabled(false)
+        return
+      }
       isZoomGesturesEnabled = zoomEnabled
       isScrollGesturesEnabled = scrollEnabled
       isRotateGesturesEnabled = rotateEnabled
       isTiltGesturesEnabled = pitchEnabled
+      isCompassEnabled = compassEnabled
       isMyLocationButtonEnabled = userLocationButtonEnabled
     }
   }
@@ -1224,33 +1341,178 @@ class GoogleMapProvider(private val context: Context) :
 
   private fun applyEdgeInsets(duration: Int = 0) {
     val combined = combinedEdgeInsets()
-    googleMap?.setPadding(combined.left, combined.top, combined.right, combined.bottom)
+    // Lite mode misrenders padding: the static image is drawn only within
+    // the padded viewport instead of the full view. The camera target shift
+    // (staticCameraTarget) compensates for insets instead.
+    if (!staticMode) {
+      googleMap?.setPadding(combined.left, combined.top, combined.right, combined.bottom)
+    }
     applyWatermarkTranslation(combined, duration)
   }
 
+  // Insets are applied by shifting the camera target so the coordinate
+  // centers in the inset viewport like a live map would (see
+  // applyEdgeInsets for why padding can't be used)
+  private fun setStaticEdgeInsets(edgeInsets: EdgeInsets) {
+    val oldInsets = this.edgeInsets
+    this.edgeInsets = edgeInsets
+    applyEdgeInsets()
+
+    val map = googleMap
+    if (map != null && oldInsets != edgeInsets) {
+      map.moveCamera(CameraUpdateFactory.newLatLngZoom(staticCameraTarget(), initialZoom))
+      positionLiveMarkers()
+    }
+  }
+
+  private fun staticCameraTarget(): LatLng {
+    val offsetX = (edgeInsets.left - edgeInsets.right) / 2.0
+    val offsetY = (edgeInsets.top - edgeInsets.bottom) / 2.0
+    if (offsetX == 0.0 && offsetY == 0.0) return LatLng(initialLatitude, initialLongitude)
+
+    val worldSize = mercatorWorldSize(initialZoom)
+    return latLngFromMercator(
+      mercatorX(initialLongitude) - offsetX / worldSize,
+      mercatorY(initialLatitude) - offsetY / worldSize
+    )
+  }
+
+  // A static camera can't fit with map padding (lite mode misrenders it);
+  // compute the fitted camera in mercator space instead, shifting the
+  // center for asymmetric padding like edge insets
+  private fun fitStaticCoordinates(
+    coordinates: List<LatLng>,
+    top: Int,
+    left: Int,
+    bottom: Int,
+    right: Int
+  ) {
+    val map = googleMap ?: return
+    val wrapper = wrapperView ?: return
+    if (wrapper.width == 0 || wrapper.height == 0) return
+
+    var minX = Double.MAX_VALUE
+    var minY = Double.MAX_VALUE
+    var maxX = -Double.MAX_VALUE
+    var maxY = -Double.MAX_VALUE
+    for (coordinate in coordinates) {
+      val x = mercatorX(coordinate.longitude)
+      val y = mercatorY(coordinate.latitude)
+      minX = minOf(minX, x)
+      maxX = maxOf(maxX, x)
+      minY = minOf(minY, y)
+      maxY = maxOf(maxY, y)
+    }
+
+    val insets = combinedEdgeInsets()
+    val availWidth = (wrapper.width - insets.left - insets.right - left - right).coerceAtLeast(1)
+    val availHeight = (wrapper.height - insets.top - insets.bottom - top - bottom).coerceAtLeast(1)
+
+    // World size in px at which the bounds fit the padded viewport;
+    // infinite for coincident coordinates - keep the current zoom then
+    val fitWorldSize = minOf(availWidth / (maxX - minX), availHeight / (maxY - minY))
+    if (fitWorldSize.isFinite()) {
+      initialZoom = log2(fitWorldSize / 256f.dpToPx())
+        .toFloat()
+        .coerceIn(map.minZoomLevel, map.maxZoomLevel)
+    }
+
+    val worldSize = mercatorWorldSize(initialZoom)
+    val center = latLngFromMercator(
+      (minX + maxX) / 2.0 - (left - right) / 2.0 / worldSize,
+      (minY + maxY) / 2.0 - (top - bottom) / 2.0 / worldSize
+    )
+    initialLatitude = center.latitude
+    initialLongitude = center.longitude
+
+    map.moveCamera(CameraUpdateFactory.newLatLngZoom(staticCameraTarget(), initialZoom))
+    positionLiveMarkers()
+  }
+
+  // Web mercator world space in [0, 1]
+  private fun mercatorX(longitude: Double): Double = (longitude + 180.0) / 360.0
+
+  private fun mercatorY(latitude: Double): Double {
+    val sinLat = sin(Math.toRadians(latitude))
+    return 0.5 - ln((1.0 + sinLat) / (1.0 - sinLat)) / (4.0 * Math.PI)
+  }
+
+  private fun latLngFromMercator(x: Double, y: Double): LatLng =
+    LatLng(Math.toDegrees(atan(sinh(Math.PI * (1.0 - 2.0 * y)))), x * 360.0 - 180.0)
+
+  // World size in px at the given zoom
+  private fun mercatorWorldSize(zoom: Float): Double = 256f.dpToPx().toDouble() * 2.0.pow(zoom.toDouble())
+
+  // Whether the renderer repositions the watermark for setPadding varies by
+  // renderer version and by whether the watermark existed when padding was
+  // set (and lite mode never applies padding). Measure where layout actually
+  // placed it and translate only for the remainder.
   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
-      }
+    attachWatermarkLayoutListener()
+
+    if (view.height == 0) return
+    val watermark = view.findViewByTag("GoogleWatermark") ?: return
+
+    // Layout position relative to the map view, excluding translation
+    var left = 0
+    var top = 0
+    var current: View? = watermark
+    while (current != null && current !== view) {
+      left += current.left
+      top += current.top
+      current = current.parent as? View
+    }
+    if (current == null) return
+
+    val bottomGap = view.height - (top + watermark.height)
+    val targetY = if (bottomGap >= insets.bottom) 0f else -insets.bottom.toFloat()
+    val targetX = if (left >= insets.left) 0f else insets.left.toFloat()
+
+    // Skip when already applied (or animating) toward this target so layout
+    // passes don't snap an in-flight animation
+    if (watermark === watermarkView && targetX == watermarkTargetX && targetY == watermarkTargetY) {
+      return
+    }
+    watermarkView = watermark
+    watermarkTargetX = targetX
+    watermarkTargetY = targetY
+
+    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 attachWatermarkLayoutListener() {
+    if (watermarkLayoutListener != null) return
+    val view = mapView ?: return
+
+    val listener = ViewTreeObserver.OnGlobalLayoutListener {
+      applyWatermarkTranslation(combinedEdgeInsets())
+    }
+    watermarkLayoutListener = listener
+    view.viewTreeObserver.addOnGlobalLayoutListener(listener)
+  }
+
+  private fun detachWatermarkLayoutListener() {
+    watermarkView = null
+    val listener = watermarkLayoutListener ?: return
+    watermarkLayoutListener = null
+    mapView?.viewTreeObserver?.takeIf { it.isAlive }?.removeOnGlobalLayoutListener(listener)
+  }
+
   private fun attachWindowInsetsListener() {
     val view = mapView ?: return
     ViewCompat.setOnApplyWindowInsetsListener(view) { _, windowInsets ->
@@ -1304,5 +1566,9 @@ class GoogleMapProvider(private val context: Context) :
 
   companion object {
     const val DEMO_MAP_ID = "DEMO_MAP_ID"
+
+    // Undocumented cap on the lite mode bitmap (2048 minus a 2px border,
+    // measured empirically)
+    private const val LITE_MODE_MAX_SIZE = 2046
   }
 }

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

@@ -30,6 +30,7 @@ interface MapProvider {
   fun setScrollEnabled(enabled: Boolean)
   fun setRotateEnabled(enabled: Boolean)
   fun setPitchEnabled(enabled: Boolean)
+  fun setCompassEnabled(enabled: Boolean)
   fun setUserLocationEnabled(enabled: Boolean)
   fun setUserLocationButtonEnabled(enabled: Boolean)
   fun setMapType(value: String)