@lugg/maps 0.2.0-alpha.3 → 0.2.0-alpha.30

package/android/src/main/java/com/luggmaps/{LuggGoogleMapView.kt → core/GoogleMapProvider.kt}

@@ -1,13 +1,10 @@
-package com.luggmaps
+package com.luggmaps.core
 
 import android.annotation.SuppressLint
-import android.util.Log
+import android.content.Context
 import android.view.View
-import android.view.ViewGroup
 import com.facebook.react.uimanager.PixelUtil.dpToPx
-import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.util.RNLog
-import com.facebook.react.views.view.ReactViewGroup
 import com.google.android.gms.maps.CameraUpdateFactory
 import com.google.android.gms.maps.GoogleMap
 import com.google.android.gms.maps.GoogleMapOptions
@@ -15,32 +12,16 @@ 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.AdvancedMarkerOptions.CollisionBehavior
 import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.MapColorScheme
 import com.google.android.gms.maps.model.PolylineOptions
-import com.luggmaps.core.PolylineAnimator
-
-interface LuggGoogleMapViewEventDelegate {
-  fun onCameraMove(
-    view: LuggGoogleMapView,
-    latitude: Double,
-    longitude: Double,
-    zoom: Float,
-    gesture: Boolean
-  )
-  fun onCameraIdle(
-    view: LuggGoogleMapView,
-    latitude: Double,
-    longitude: Double,
-    zoom: Float,
-    gesture: Boolean
-  )
-  fun onReady(view: LuggGoogleMapView)
-}
+import com.luggmaps.LuggMarkerView
+import com.luggmaps.LuggMarkerViewDelegate
+import com.luggmaps.LuggPolylineView
+import com.luggmaps.LuggPolylineViewDelegate
 
-@SuppressLint("ViewConstructor")
-class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
-  ReactViewGroup(reactContext),
+class GoogleMapProvider(private val context: Context) :
+  MapProvider,
   OnMapReadyCallback,
   LuggMarkerViewDelegate,
   LuggPolylineViewDelegate,
@@ -48,21 +29,23 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
   GoogleMap.OnCameraMoveListener,
   GoogleMap.OnCameraIdleListener {
 
-  var eventDelegate: LuggGoogleMapViewEventDelegate? = null
+  override var delegate: MapProviderDelegate? = null
+  override val isMapReady: Boolean get() = _isMapReady
+
+  var mapId: String = DEMO_MAP_ID
+
   private var mapView: MapView? = null
-  private var mapWrapperView: LuggMapWrapperView? = null
   private var googleMap: GoogleMap? = null
-  private var isMapReady = false
+  private var _isMapReady = false
   private var isDragging = false
-  private var mapId: String = DEMO_MAP_ID
-  private val pendingMarkerViews = mutableListOf<LuggMarkerView>()
-  private val pendingPolylineViews = mutableListOf<LuggPolylineView>()
+  private val pendingMarkerViews = mutableSetOf<LuggMarkerView>()
+  private val pendingPolylineViews = mutableSetOf<LuggPolylineView>()
   private val polylineAnimators = mutableMapOf<LuggPolylineView, PolylineAnimator>()
 
   // Initial camera settings
-  private var initialLatitude: Double = 37.78
-  private var initialLongitude: Double = -122.43
-  private var initialZoom: Float = 14f
+  private var initialLatitude: Double = 0.0
+  private var initialLongitude: Double = 0.0
+  private var initialZoom: Float = 10f
 
   // UI settings
   private var zoomEnabled: Boolean = true
@@ -70,95 +53,55 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
   private var rotateEnabled: Boolean = true
   private var pitchEnabled: Boolean = true
   private var userLocationEnabled: Boolean = false
+  private var userLocationButtonEnabled: Boolean = false
 
   // Zoom limits
   private var minZoom: Float? = null
   private var maxZoom: Float? = null
 
-  // Padding
-  private var paddingTop: Int = 0
-  private var paddingLeft: Int = 0
-  private var paddingBottom: Int = 0
-  private var paddingRight: Int = 0
+  // Theme
+  private var theme: String = "system"
 
-  // region View Lifecycle
+  // Edge Insets
+  private var edgeInsets: EdgeInsets = EdgeInsets()
 
-  override fun addView(child: View?, index: Int) {
-    super.addView(child, index)
-    when (child) {
-      is LuggMapWrapperView -> mapWrapperView = child
+  // region MapProvider
 
-      is LuggMarkerView -> {
-        child.delegate = this
-        syncMarkerView(child)
-      }
+  override fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float) {
+    if (mapView != null) return
 
-      is LuggPolylineView -> {
-        child.delegate = this
-        syncPolylineView(child)
-      }
-    }
-  }
-
-  override fun removeViewAt(index: Int) {
-    val view = getChildAt(index)
-    if (view is LuggMarkerView) {
-      Log.d(TAG, "removing markerView: ${view.name}")
-      view.marker?.remove()
-      view.marker = null
-    } else if (view is LuggPolylineView) {
-      polylineAnimators[view]?.destroy()
-      polylineAnimators.remove(view)
-      view.polyline?.remove()
-      view.polyline = null
-    }
-    super.removeViewAt(index)
-  }
+    initialLatitude = latitude
+    initialLongitude = longitude
+    initialZoom = zoom
 
-  override fun onAttachedToWindow() {
-    super.onAttachedToWindow()
-    if (mapView == null && mapWrapperView != null) {
-      initializeMap()
+    val options = GoogleMapOptions().mapId(mapId)
+    mapView = MapView(context, options).also { view ->
+      view.onCreate(null)
+      view.onResume()
+      view.getMapAsync(this)
+      (wrapperView as android.view.ViewGroup).addView(view)
     }
   }
 
-  fun onDropViewInstance() {
-    Log.d(TAG, "dropping mapView instance")
+  override fun destroy() {
     pendingMarkerViews.clear()
     pendingPolylineViews.clear()
     polylineAnimators.values.forEach { it.destroy() }
     polylineAnimators.clear()
+    googleMap?.setOnCameraMoveStartedListener(null)
+    googleMap?.setOnCameraMoveListener(null)
+    googleMap?.setOnCameraIdleListener(null)
     googleMap?.clear()
     googleMap = null
-    isMapReady = false
+    _isMapReady = false
     mapView?.onPause()
     mapView?.onDestroy()
     mapView = null
-    mapWrapperView = null
-  }
-
-  // endregion
-
-  // region Map Initialization
-
-  private fun initializeMap() {
-    if (mapView != null || mapWrapperView == null) return
-
-    val options = GoogleMapOptions().mapId(mapId)
-    mapView = MapView(context, options).also { view ->
-      view.onCreate(null)
-      view.onResume()
-      view.getMapAsync(this)
-      mapWrapperView?.addView(
-        view,
-        LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
-      )
-    }
   }
 
   override fun onMapReady(map: GoogleMap) {
     googleMap = map
-    isMapReady = true
+    _isMapReady = true
 
     val position = LatLng(initialLatitude, initialLongitude)
     map.moveCamera(CameraUpdateFactory.newLatLngZoom(position, initialZoom))
@@ -169,53 +112,69 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
     applyUiSettings()
     applyZoomLimits()
-    applyPadding()
+    applyEdgeInsets()
+    applyTheme()
     applyUserLocation()
     processPendingMarkers()
     processPendingPolylines()
 
-    eventDelegate?.onReady(this)
+    delegate?.mapProviderDidReady()
   }
 
+  // endregion
+
+  // region Camera Listeners
+
   override fun onCameraMoveStarted(reason: Int) {
     isDragging = reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE
+    if (isDragging) {
+      polylineAnimators.values.forEach { it.pause() }
+    }
   }
 
   override fun onCameraMove() {
     val map = googleMap ?: return
     val position = map.cameraPosition
-    eventDelegate?.onCameraMove(this, position.target.latitude, position.target.longitude, position.zoom, isDragging)
+    delegate?.mapProviderDidMoveCamera(position.target.latitude, position.target.longitude, position.zoom, isDragging)
   }
 
   override fun onCameraIdle() {
     val map = googleMap ?: return
     val position = map.cameraPosition
-    eventDelegate?.onCameraIdle(this, position.target.latitude, position.target.longitude, position.zoom, isDragging)
+    delegate?.mapProviderDidIdleCamera(position.target.latitude, position.target.longitude, position.zoom, isDragging)
+    if (isDragging) {
+      polylineAnimators.values.forEach { it.resume() }
+    }
     isDragging = false
   }
 
-  private fun applyUiSettings() {
-    googleMap?.uiSettings?.apply {
-      isZoomGesturesEnabled = zoomEnabled
-      isScrollGesturesEnabled = scrollEnabled
-      isRotateGesturesEnabled = rotateEnabled
-      isTiltGesturesEnabled = pitchEnabled
-    }
+  // endregion
+
+  // region Props
+
+  override fun setZoomEnabled(enabled: Boolean) {
+    zoomEnabled = enabled
+    googleMap?.uiSettings?.isZoomGesturesEnabled = enabled
   }
 
-  private fun applyZoomLimits() {
-    googleMap?.apply {
-      minZoom?.let { setMinZoomPreference(it) }
-      maxZoom?.let { setMaxZoomPreference(it) }
-    }
+  override fun setScrollEnabled(enabled: Boolean) {
+    scrollEnabled = enabled
+    googleMap?.uiSettings?.isScrollGesturesEnabled = enabled
   }
 
-  private fun applyPadding() {
-    googleMap?.setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom)
+  override fun setRotateEnabled(enabled: Boolean) {
+    rotateEnabled = enabled
+    googleMap?.uiSettings?.isRotateGesturesEnabled = enabled
+  }
+
+  override fun setPitchEnabled(enabled: Boolean) {
+    pitchEnabled = enabled
+    googleMap?.uiSettings?.isTiltGesturesEnabled = enabled
   }
 
   @SuppressLint("MissingPermission")
-  private fun applyUserLocation() {
+  override fun setUserLocationEnabled(enabled: Boolean) {
+    userLocationEnabled = enabled
     val hasPermission =
       context.checkSelfPermission(
         android.Manifest.permission.ACCESS_FINE_LOCATION
@@ -225,12 +184,59 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     googleMap?.isMyLocationEnabled = userLocationEnabled && hasPermission
   }
 
-  // endregion
+  override fun setUserLocationButtonEnabled(enabled: Boolean) {
+    userLocationButtonEnabled = enabled
+    googleMap?.uiSettings?.isMyLocationButtonEnabled = enabled
+  }
 
-  // region PolylineViewDelegate
+  override fun setTheme(value: String) {
+    theme = value
+    applyTheme()
+  }
 
-  override fun polylineViewDidUpdate(polylineView: LuggPolylineView) {
-    syncPolylineView(polylineView)
+  override fun setMinZoom(zoom: Double) {
+    minZoom = if (zoom > 0) zoom.toFloat() else null
+    googleMap?.let { map ->
+      minZoom?.let { map.setMinZoomPreference(it) } ?: map.resetMinMaxZoomPreference()
+    }
+  }
+
+  override fun setMaxZoom(zoom: Double) {
+    maxZoom = if (zoom > 0) zoom.toFloat() else null
+    googleMap?.let { map ->
+      maxZoom?.let { map.setMaxZoomPreference(it) } ?: map.resetMinMaxZoomPreference()
+    }
+  }
+
+  override fun setEdgeInsets(edgeInsets: EdgeInsets) {
+    val oldInsets = this.edgeInsets
+    this.edgeInsets = edgeInsets
+    applyEdgeInsets()
+
+    val map = googleMap
+    if (map != null && oldInsets != edgeInsets) {
+      mapView?.post {
+        setEdgeInsets(edgeInsets, 0)
+      }
+    }
+  }
+
+  override fun setEdgeInsets(edgeInsets: EdgeInsets, duration: Int) {
+    val map = googleMap
+    val oldInsets = this.edgeInsets
+    this.edgeInsets = edgeInsets
+
+    if (map != null && oldInsets != edgeInsets) {
+      val cameraUpdate = CameraUpdateFactory.newCameraPosition(map.cameraPosition)
+      applyEdgeInsets()
+      when {
+        duration < 0 -> map.animateCamera(cameraUpdate)
+        duration > 0 -> map.animateCamera(cameraUpdate, duration, null)
+        else -> map.moveCamera(cameraUpdate)
+      }
+    } else {
+      applyEdgeInsets()
+    }
   }
 
   // endregion
@@ -239,16 +245,12 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   override fun markerViewDidLayout(markerView: LuggMarkerView) {
     if (googleMap == null) {
-      if (!pendingMarkerViews.contains(markerView)) {
-        pendingMarkerViews.add(markerView)
-      }
+      pendingMarkerViews.add(markerView)
       return
     }
 
     if (markerView.hasCustomView) {
-      // Recreate marker with custom view
-      markerView.marker?.remove()
-      addMarkerViewToMap(markerView)
+      markerView.updateIcon { addMarkerViewToMap(markerView) }
     } else {
       syncMarkerView(markerView)
     }
@@ -260,18 +262,33 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   // endregion
 
+  // region PolylineViewDelegate
+
+  override fun polylineViewDidUpdate(polylineView: LuggPolylineView) {
+    syncPolylineView(polylineView)
+  }
+
+  // endregion
+
   // region Marker Management
 
+  override fun addMarkerView(markerView: LuggMarkerView) {
+    markerView.delegate = this
+    syncMarkerView(markerView)
+  }
+
+  override fun removeMarkerView(markerView: LuggMarkerView) {
+    markerView.marker?.remove()
+    markerView.marker = null
+  }
+
   private fun syncMarkerView(markerView: LuggMarkerView) {
     if (googleMap == null) {
-      if (!pendingMarkerViews.contains(markerView)) {
-        pendingMarkerViews.add(markerView)
-      }
+      pendingMarkerViews.add(markerView)
       return
     }
 
     if (markerView.marker == null) {
-      // Custom views need layout first before adding to map
       if (markerView.hasCustomView) return
       addMarkerViewToMap(markerView)
       return
@@ -282,57 +299,59 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
       title = markerView.title
       snippet = markerView.description
       setAnchor(markerView.anchorX, markerView.anchorY)
-      if (!markerView.hasCustomView) {
-        iconView = null
-      }
+      zIndex = markerView.zIndex
+      rotation = markerView.rotate
+    }
+
+    if (markerView.hasCustomView && markerView.scaleChanged) {
+      markerView.applyScaleToMarker()
+      markerView.clearScaleChanged()
     }
   }
 
   private fun processPendingMarkers() {
     if (googleMap == null) return
-
-    Log.d(TAG, "processing pending markers ${pendingMarkerViews.size}")
     pendingMarkerViews.forEach { addMarkerViewToMap(it) }
     pendingMarkerViews.clear()
   }
 
   private fun addMarkerViewToMap(markerView: LuggMarkerView) {
-    val map = googleMap ?: run {
-      RNLog.w(reactContext, "Lugg: addMarkerViewToMap called without a map")
-      return
-    }
+    val map = googleMap ?: return
 
     val position = LatLng(markerView.latitude, markerView.longitude)
-    val iconView = markerView.iconView
-
-    (iconView.parent as? ViewGroup)?.removeView(iconView)
-
     val options = AdvancedMarkerOptions()
       .position(position)
       .title(markerView.title)
       .snippet(markerView.description)
-      .collisionBehavior(CollisionBehavior.REQUIRED)
-
-    Log.d(TAG, "adding marker: ${markerView.name} customview: ${markerView.hasCustomView}")
-    if (markerView.hasCustomView) {
-      options.iconView(iconView)
-    }
 
     val marker = map.addMarker(options) as AdvancedMarker
     marker.setAnchor(markerView.anchorX, markerView.anchorY)
+    marker.zIndex = markerView.zIndex
+    marker.rotation = markerView.rotate
 
     markerView.marker = marker
+    markerView.applyIconToMarker()
   }
 
   // endregion
 
   // region Polyline Management
 
+  override fun addPolylineView(polylineView: LuggPolylineView) {
+    polylineView.delegate = this
+    syncPolylineView(polylineView)
+  }
+
+  override fun removePolylineView(polylineView: LuggPolylineView) {
+    polylineAnimators[polylineView]?.destroy()
+    polylineAnimators.remove(polylineView)
+    polylineView.polyline?.remove()
+    polylineView.polyline = null
+  }
+
   private fun syncPolylineView(polylineView: LuggPolylineView) {
     if (googleMap == null) {
-      if (!pendingPolylineViews.contains(polylineView)) {
-        pendingPolylineViews.add(polylineView)
-      }
+      pendingPolylineViews.add(polylineView)
       return
     }
 
@@ -342,11 +361,13 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     }
 
     polylineView.polyline?.width = polylineView.strokeWidth.dpToPx()
+    polylineView.polyline?.zIndex = polylineView.zIndex
 
     polylineAnimators[polylineView]?.apply {
       coordinates = polylineView.coordinates
       strokeColors = polylineView.strokeColors
       strokeWidth = polylineView.strokeWidth.dpToPx()
+      animatedOptions = polylineView.animatedOptions
       animated = polylineView.animated
       update()
     }
@@ -354,7 +375,6 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   private fun processPendingPolylines() {
     if (googleMap == null) return
-
     pendingPolylineViews.forEach { addPolylineViewToMap(it) }
     pendingPolylineViews.clear()
   }
@@ -364,6 +384,7 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
     val options = PolylineOptions()
       .width(polylineView.strokeWidth.dpToPx())
+      .zIndex(polylineView.zIndex)
 
     val polyline = map.addPolyline(options)
     polylineView.polyline = polyline
@@ -373,6 +394,7 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
       coordinates = polylineView.coordinates
       strokeColors = polylineView.strokeColors
       strokeWidth = polylineView.strokeWidth.dpToPx()
+      animatedOptions = polylineView.animatedOptions
       animated = polylineView.animated
       update()
     }
@@ -382,83 +404,25 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   // endregion
 
-  // region Property Setters
-
-  fun setMapId(value: String?) {
-    if (value.isNullOrEmpty()) return
-
-    if (mapView != null) {
-      RNLog.w(reactContext, "Lugg: mapId cannot be changed after map is initialized")
-      return
-    }
-
-    mapId = value
-  }
-
-  fun setInitialCoordinate(latitude: Double, longitude: Double) {
-    initialLatitude = latitude
-    initialLongitude = longitude
-  }
-
-  fun setInitialZoom(zoom: Double) {
-    initialZoom = zoom.toFloat()
-  }
-
-  fun setZoomEnabled(enabled: Boolean) {
-    zoomEnabled = enabled
-    googleMap?.uiSettings?.isZoomGesturesEnabled = enabled
-  }
-
-  fun setScrollEnabled(enabled: Boolean) {
-    scrollEnabled = enabled
-    googleMap?.uiSettings?.isScrollGesturesEnabled = enabled
-  }
-
-  fun setRotateEnabled(enabled: Boolean) {
-    rotateEnabled = enabled
-    googleMap?.uiSettings?.isRotateGesturesEnabled = enabled
-  }
-
-  fun setPitchEnabled(enabled: Boolean) {
-    pitchEnabled = enabled
-    googleMap?.uiSettings?.isTiltGesturesEnabled = enabled
-  }
-
-  fun setUserLocationEnabled(enabled: Boolean) {
-    userLocationEnabled = enabled
-    applyUserLocation()
-  }
+  // region Lifecycle
 
-  fun setMinZoom(zoom: Double) {
-    minZoom = if (zoom > 0) zoom.toFloat() else null
-    googleMap?.let { map ->
-      minZoom?.let { map.setMinZoomPreference(it) } ?: map.resetMinMaxZoomPreference()
-    }
+  override fun pauseAnimations() {
+    polylineAnimators.values.forEach { it.pause() }
   }
 
-  fun setMaxZoom(zoom: Double) {
-    maxZoom = if (zoom > 0) zoom.toFloat() else null
-    googleMap?.let { map ->
-      maxZoom?.let { map.setMaxZoomPreference(it) } ?: map.resetMinMaxZoomPreference()
-    }
-  }
-
-  fun setMapPadding(top: Int, left: Int, bottom: Int, right: Int) {
-    paddingTop = top
-    paddingLeft = left
-    paddingBottom = bottom
-    paddingRight = right
-    applyPadding()
+  override fun resumeAnimations() {
+    polylineAnimators.values.forEach { it.resume() }
   }
 
   // endregion
 
   // region Commands
 
-  fun moveCamera(latitude: Double, longitude: Double, zoom: Double, duration: Int) {
+  override fun moveCamera(latitude: Double, longitude: Double, zoom: Double, duration: Int) {
     val map = googleMap ?: return
     val position = LatLng(latitude, longitude)
-    val cameraUpdate = CameraUpdateFactory.newLatLngZoom(position, zoom.toFloat())
+    val targetZoom = if (zoom > 0) zoom.toFloat() else map.cameraPosition.zoom
+    val cameraUpdate = CameraUpdateFactory.newLatLngZoom(position, targetZoom)
     when {
       duration < 0 -> map.animateCamera(cameraUpdate)
       duration > 0 -> map.animateCamera(cameraUpdate, duration, null)
@@ -466,32 +430,34 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     }
   }
 
-  fun fitCoordinates(
-    coordinates: List<LatLng>,
-    paddingTop: Int,
-    paddingLeft: Int,
-    paddingBottom: Int,
-    paddingRight: Int,
+  override fun fitCoordinates(
+    coordinates: List<Any>,
+    edgeInsetsTop: Int,
+    edgeInsetsLeft: Int,
+    edgeInsetsBottom: Int,
+    edgeInsetsRight: Int,
     duration: Int
   ) {
     val map = googleMap ?: return
     if (coordinates.isEmpty()) return
 
+    val latLngs = coordinates.filterIsInstance<LatLng>()
+    if (latLngs.isEmpty()) return
+
     val boundsBuilder = com.google.android.gms.maps.model.LatLngBounds.Builder()
-    coordinates.forEach { boundsBuilder.include(it) }
+    latLngs.forEach { boundsBuilder.include(it) }
     val bounds = boundsBuilder.build()
 
-    val top = paddingTop.toFloat().dpToPx().toInt()
-    val left = paddingLeft.toFloat().dpToPx().toInt()
-    val bottom = paddingBottom.toFloat().dpToPx().toInt()
-    val right = paddingRight.toFloat().dpToPx().toInt()
+    val top = edgeInsetsTop.toFloat().dpToPx().toInt()
+    val left = edgeInsetsLeft.toFloat().dpToPx().toInt()
+    val bottom = edgeInsetsBottom.toFloat().dpToPx().toInt()
+    val right = edgeInsetsRight.toFloat().dpToPx().toInt()
 
-    // Set padding before camera update, then restore after
     map.setPadding(
-      this.paddingLeft + left,
-      this.paddingTop + top,
-      this.paddingRight + right,
-      this.paddingBottom + bottom
+      edgeInsets.left + left,
+      edgeInsets.top + top,
+      edgeInsets.right + right,
+      edgeInsets.bottom + bottom
     )
 
     val cameraUpdate = CameraUpdateFactory.newLatLngBounds(bounds, 0)
@@ -502,14 +468,58 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
       else -> map.moveCamera(cameraUpdate)
     }
 
-    // Restore base padding
-    map.setPadding(this.paddingLeft, this.paddingTop, this.paddingRight, this.paddingBottom)
+    map.setPadding(edgeInsets.left, edgeInsets.top, edgeInsets.right, edgeInsets.bottom)
+  }
+
+  // endregion
+
+  // region Private
+
+  private fun applyUiSettings() {
+    googleMap?.uiSettings?.apply {
+      isZoomGesturesEnabled = zoomEnabled
+      isScrollGesturesEnabled = scrollEnabled
+      isRotateGesturesEnabled = rotateEnabled
+      isTiltGesturesEnabled = pitchEnabled
+      isMyLocationButtonEnabled = userLocationButtonEnabled
+    }
+  }
+
+  private fun applyZoomLimits() {
+    googleMap?.apply {
+      minZoom?.let { setMinZoomPreference(it) }
+      maxZoom?.let { setMaxZoomPreference(it) }
+    }
+  }
+
+  private fun applyEdgeInsets() {
+    googleMap?.setPadding(edgeInsets.left, edgeInsets.top, edgeInsets.right, edgeInsets.bottom)
+  }
+
+  private fun applyTheme() {
+    val colorScheme = when (theme) {
+      "dark" -> MapColorScheme.DARK
+      "light" -> MapColorScheme.LIGHT
+      else -> MapColorScheme.FOLLOW_SYSTEM
+    }
+    googleMap?.setMapColorScheme(colorScheme)
+  }
+
+  @SuppressLint("MissingPermission")
+  private fun applyUserLocation() {
+    val hasPermission =
+      context.checkSelfPermission(
+        android.Manifest.permission.ACCESS_FINE_LOCATION
+      ) == android.content.pm.PackageManager.PERMISSION_GRANTED ||
+        context.checkSelfPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION) ==
+        android.content.pm.PackageManager.PERMISSION_GRANTED
+    googleMap?.isMyLocationEnabled = userLocationEnabled && hasPermission
+    googleMap?.uiSettings?.isMyLocationButtonEnabled = userLocationButtonEnabled
   }
 
   // endregion
 
   companion object {
-    private const val TAG = "Lugg"
     const val DEMO_MAP_ID = "DEMO_MAP_ID"
   }
 }