@lugg/maps 0.2.0-alpha.22 → 0.2.0-alpha.24

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

@@ -1,12 +1,10 @@
-package com.luggmaps
+package com.luggmaps.core
 
 import android.annotation.SuppressLint
+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
@@ -14,33 +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 = 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
@@ -79,84 +62,42 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
   private var theme: String = "system"
 
   // Padding
-  private var paddingTop: Int = 0
-  private var paddingLeft: Int = 0
-  private var paddingBottom: Int = 0
-  private var paddingRight: Int = 0
-
-  // region View Lifecycle
-
-  override fun addView(child: View?, index: Int) {
-    super.addView(child, index)
-    when (child) {
-      is LuggMapWrapperView -> mapWrapperView = child
-
-      is LuggMarkerView -> {
-        child.delegate = this
-        syncMarkerView(child)
-      }
-
-      is LuggPolylineView -> {
-        child.delegate = this
-        syncPolylineView(child)
-      }
-    }
-  }
+  private var padding: EdgeInsets = EdgeInsets()
 
-  override fun removeViewAt(index: Int) {
-    val view = getChildAt(index)
-    if (view is LuggMarkerView) {
-      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)
-  }
+  // region MapProvider
 
-  override fun onAttachedToWindow() {
-    super.onAttachedToWindow()
-    if (mapView == null && mapWrapperView != null) {
-      initializeMap()
+  override fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float) {
+    if (mapView != null) return
+
+    initialLatitude = latitude
+    initialLongitude = longitude
+    initialZoom = zoom
+
+    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() {
+  override fun destroy() {
     pendingMarkerViews.clear()
     pendingPolylineViews.clear()
     polylineAnimators.values.forEach { it.destroy() }
     polylineAnimators.clear()
     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)
-    }
   }
 
   override fun onMapReady(map: GoogleMap) {
     googleMap = map
-    isMapReady = true
+    _isMapReady = true
 
     val position = LatLng(initialLatitude, initialLongitude)
     map.moveCamera(CameraUpdateFactory.newLatLngZoom(position, initialZoom))
@@ -173,9 +114,13 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     processPendingMarkers()
     processPendingPolylines()
 
-    eventDelegate?.onReady(this)
+    delegate?.mapProviderDidReady()
   }
 
+  // endregion
+
+  // region Camera Listeners
+
   override fun onCameraMoveStarted(reason: Int) {
     isDragging = reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE
     if (isDragging) {
@@ -186,50 +131,46 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
   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
   }
 
-  private fun applyTheme() {
-    val colorScheme = when (theme) {
-      "dark" -> MapColorScheme.DARK
-      "light" -> MapColorScheme.LIGHT
-      else -> MapColorScheme.FOLLOW_SYSTEM
-    }
-    googleMap?.setMapColorScheme(colorScheme)
+  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
@@ -239,12 +180,28 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     googleMap?.isMyLocationEnabled = userLocationEnabled && hasPermission
   }
 
-  // endregion
+  override fun setTheme(value: String) {
+    theme = value
+    applyTheme()
+  }
 
-  // region PolylineViewDelegate
+  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 polylineViewDidUpdate(polylineView: LuggPolylineView) {
-    syncPolylineView(polylineView)
+  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 setPadding(padding: EdgeInsets) {
+    this.padding = padding
+    applyPadding()
   }
 
   // endregion
@@ -270,8 +227,26 @@ 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) {
       pendingMarkerViews.add(markerView)
@@ -279,7 +254,6 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     }
 
     if (markerView.marker == null) {
-      // Custom views need layout first before adding to map
       if (markerView.hasCustomView) return
       addMarkerViewToMap(markerView)
       return
@@ -302,19 +276,14 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   private fun processPendingMarkers() {
     if (googleMap == null) return
-
     pendingMarkerViews.forEach { addMarkerViewToMap(it) }
     pendingMarkerViews.clear()
   }
 
   private fun addMarkerViewToMap(markerView: LuggMarkerView) {
-    val map = googleMap ?: run {
-      RNLog.w(reactContext, "LuggMaps: addMarkerViewToMap called without a map")
-      return
-    }
+    val map = googleMap ?: return
 
     val position = LatLng(markerView.latitude, markerView.longitude)
-
     val options = AdvancedMarkerOptions()
       .position(position)
       .title(markerView.title)
@@ -333,6 +302,18 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   // 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) {
       pendingPolylineViews.add(polylineView)
@@ -359,7 +340,6 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   private fun processPendingPolylines() {
     if (googleMap == null) return
-
     pendingPolylineViews.forEach { addPolylineViewToMap(it) }
     pendingPolylineViews.clear()
   }
@@ -389,85 +369,21 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
 
   // endregion
 
-  // region Property Setters
-
-  fun setMapId(value: String?) {
-    if (value.isNullOrEmpty()) return
-
-    if (mapView != null) {
-      RNLog.w(reactContext, "LuggMaps: 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()
-  }
-
-  fun setMinZoom(zoom: Double) {
-    minZoom = if (zoom > 0) zoom.toFloat() else null
-    googleMap?.let { map ->
-      minZoom?.let { map.setMinZoomPreference(it) } ?: map.resetMinMaxZoomPreference()
-    }
-  }
-
-  fun setMaxZoom(zoom: Double) {
-    maxZoom = if (zoom > 0) zoom.toFloat() else null
-    googleMap?.let { map ->
-      maxZoom?.let { map.setMaxZoomPreference(it) } ?: map.resetMinMaxZoomPreference()
-    }
-  }
+  // region Lifecycle
 
-  fun setTheme(value: String) {
-    theme = value
-    applyTheme()
+  override fun pauseAnimations() {
+    polylineAnimators.values.forEach { it.pause() }
   }
 
-  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 targetZoom = if (zoom > 0) zoom.toFloat() else map.cameraPosition.zoom
@@ -479,8 +395,8 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     }
   }
 
-  fun fitCoordinates(
-    coordinates: List<LatLng>,
+  override fun fitCoordinates(
+    coordinates: List<Any>,
     paddingTop: Int,
     paddingLeft: Int,
     paddingBottom: Int,
@@ -490,8 +406,11 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     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()
@@ -499,12 +418,11 @@ class LuggGoogleMapView(private val reactContext: ThemedReactContext) :
     val bottom = paddingBottom.toFloat().dpToPx().toInt()
     val right = paddingRight.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
+      padding.left + left,
+      padding.top + top,
+      padding.right + right,
+      padding.bottom + bottom
     )
 
     val cameraUpdate = CameraUpdateFactory.newLatLngBounds(bounds, 0)
@@ -515,14 +433,56 @@ 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(padding.left, padding.top, padding.right, padding.bottom)
+  }
+
+  // endregion
+
+  // region Private
+
+  private fun applyUiSettings() {
+    googleMap?.uiSettings?.apply {
+      isZoomGesturesEnabled = zoomEnabled
+      isScrollGesturesEnabled = scrollEnabled
+      isRotateGesturesEnabled = rotateEnabled
+      isTiltGesturesEnabled = pitchEnabled
+    }
+  }
+
+  private fun applyZoomLimits() {
+    googleMap?.apply {
+      minZoom?.let { setMinZoomPreference(it) }
+      maxZoom?.let { setMaxZoomPreference(it) }
+    }
+  }
+
+  private fun applyPadding() {
+    googleMap?.setPadding(padding.left, padding.top, padding.right, padding.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
   }
 
   // endregion
 
   companion object {
-    private const val TAG = "Lugg"
     const val DEMO_MAP_ID = "DEMO_MAP_ID"
   }
 }

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

@@ -0,0 +1,53 @@
+package com.luggmaps.core
+
+import android.view.View
+import com.luggmaps.LuggMarkerView
+import com.luggmaps.LuggPolylineView
+
+data class EdgeInsets(val top: Int = 0, val left: Int = 0, val bottom: Int = 0, val right: Int = 0)
+
+interface MapProviderDelegate {
+  fun mapProviderDidReady()
+  fun mapProviderDidMoveCamera(latitude: Double, longitude: Double, zoom: Float, gesture: Boolean)
+  fun mapProviderDidIdleCamera(latitude: Double, longitude: Double, zoom: Float, gesture: Boolean)
+}
+
+interface MapProvider {
+  var delegate: MapProviderDelegate?
+  val isMapReady: Boolean
+
+  fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float)
+  fun destroy()
+
+  // Props
+  fun setZoomEnabled(enabled: Boolean)
+  fun setScrollEnabled(enabled: Boolean)
+  fun setRotateEnabled(enabled: Boolean)
+  fun setPitchEnabled(enabled: Boolean)
+  fun setUserLocationEnabled(enabled: Boolean)
+  fun setTheme(value: String)
+  fun setMinZoom(zoom: Double)
+  fun setMaxZoom(zoom: Double)
+  fun setPadding(padding: EdgeInsets)
+
+  // Children
+  fun addMarkerView(markerView: LuggMarkerView)
+  fun removeMarkerView(markerView: LuggMarkerView)
+  fun addPolylineView(polylineView: LuggPolylineView)
+  fun removePolylineView(polylineView: LuggPolylineView)
+
+  // Lifecycle
+  fun pauseAnimations()
+  fun resumeAnimations()
+
+  // Commands
+  fun moveCamera(latitude: Double, longitude: Double, zoom: Double, duration: Int)
+  fun fitCoordinates(
+    coordinates: List<Any>,
+    paddingTop: Int,
+    paddingLeft: Int,
+    paddingBottom: Int,
+    paddingRight: Int,
+    duration: Int
+  )
+}