react-native-google-maps-plus 0.1.0 → 1.0.1

package/android/src/main/java/com/googlemapsnitro/GoogleMapsNitroViewImpl.kt

@@ -0,0 +1,720 @@
+package com.googlemapsnitro
+
+import android.annotation.SuppressLint
+import android.location.Location
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.GoogleMap
+import com.google.android.gms.maps.MapView
+import com.google.android.gms.maps.OnMapReadyCallback
+import com.google.android.gms.maps.model.CameraPosition
+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.MapStyleOptions
+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.Polyline
+import com.google.android.gms.maps.model.PolylineOptions
+
+class GoogleMapsNitroViewImpl(
+  val reactContext: ThemedReactContext,
+  val locationHandler: LocationHandler,
+  val playServiceHandler: PlayServicesHandler,
+  val markerOptions: com.googlemapsnitro.MarkerOptions,
+) : MapView(reactContext),
+  GoogleMap.OnCameraMoveStartedListener,
+  GoogleMap.OnCameraMoveListener,
+  GoogleMap.OnCameraIdleListener,
+  GoogleMap.OnMapClickListener,
+  OnMapReadyCallback,
+  GoogleMap.OnMarkerClickListener,
+  LifecycleEventListener {
+  private var googleMap: GoogleMap? = null
+
+  private var pendingBuildingEnabled: Boolean = false
+  private var pendingTrafficEnabled: Boolean = false
+  private var pendingCustomMapStyle: MapStyleOptions? = null
+  private var pendingInitialCamera: CameraPosition =
+    CameraPosition
+      .builder()
+      .target(
+        LatLng(
+          0.0,
+          0.0,
+        ),
+      ).zoom(0f)
+      .bearing(0f)
+      .tilt(0f)
+      .build()
+  private var pendingUserInterfaceStyle: Int = MapColorScheme.FOLLOW_SYSTEM
+  private var pendingMinZoomLevel: Double = 0.0
+  private var pendingMaxZoomLevel: Double = 21.0
+  private var pendingMapPadding: RNMapPadding = RNMapPadding(0.0, 0.0, 0.0, 0.0)
+  private val pendingPolygons = mutableListOf<Pair<String, PolygonOptions>>()
+  private val pendingPolylines = mutableListOf<Pair<String, PolylineOptions>>()
+  private val pendingMarkers = mutableListOf<Pair<String, MarkerOptions>>()
+  private var cameraMoveReason = -1
+
+  private val polygonsById = mutableMapOf<String, Polygon>()
+  private val polylinesById = mutableMapOf<String, Polyline>()
+  private val markersById = mutableMapOf<String, Marker>()
+
+  private var lastSubmittedLocation: Location? = null
+  private var lastSubmittedCameraPosition: CameraPosition? = null
+
+  init {
+    reactContext.addLifecycleEventListener(this)
+    getMap()
+  }
+
+  private fun getMap() {
+    val result = playServiceHandler.playServicesAvailability()
+
+    when (result) {
+      ConnectionResult.SERVICE_MISSING -> {
+        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_MISSING)
+        return
+      }
+
+      ConnectionResult.SERVICE_INVALID -> {
+        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_INVALID)
+        return
+      }
+
+      ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED ->
+        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_OUTDATED)
+
+      ConnectionResult.SERVICE_UPDATING ->
+        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICE_UPDATING)
+
+      ConnectionResult.SERVICE_DISABLED ->
+        onMapError?.invoke(RNMapErrorCode.PLAY_SERVICES_DISABLED)
+
+      ConnectionResult.SUCCESS -> {}
+
+      else ->
+        onMapError?.invoke(RNMapErrorCode.UNKNOWN)
+    }
+
+    onCreate(null)
+    getMapAsync(this@GoogleMapsNitroViewImpl)
+  }
+
+  override fun onCameraMoveStarted(reason: Int) {
+    lastSubmittedCameraPosition = null
+    cameraMoveReason = reason
+    val bounds = googleMap?.projection?.visibleRegion?.latLngBounds
+    val cameraPosition = googleMap?.cameraPosition
+    if (bounds == null || cameraPosition == null) {
+      return
+    }
+    val isGesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == reason
+
+    val latDelta = bounds.northeast.latitude - bounds.southwest.latitude
+    val lngDelta = bounds.northeast.longitude - bounds.southwest.longitude
+
+    onCameraChangeStart?.invoke(
+      RNRegion(
+        center = RNLatLng(bounds.center.latitude, bounds.center.longitude),
+        latitudeDelta = latDelta,
+        longitudeDelta = lngDelta,
+      ),
+      RNCamera(
+        center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
+        zoom = cameraPosition.zoom.toDouble(),
+        bearing = cameraPosition.bearing.toDouble(),
+        tilt = cameraPosition.tilt.toDouble(),
+      ),
+      isGesture,
+    )
+  }
+
+  override fun onCameraMove() {
+    val bounds = googleMap?.projection?.visibleRegion?.latLngBounds
+    val cameraPosition = googleMap?.cameraPosition
+    if (bounds == null || cameraPosition == null) {
+      return
+    }
+    if (cameraPosition == lastSubmittedCameraPosition) {
+      return
+    }
+    val isGesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
+
+    val latDelta = bounds.northeast.latitude - bounds.southwest.latitude
+    val lngDelta = bounds.northeast.longitude - bounds.southwest.longitude
+
+    onCameraChange?.invoke(
+      RNRegion(
+        center = RNLatLng(bounds.center.latitude, bounds.center.longitude),
+        latitudeDelta = latDelta,
+        longitudeDelta = lngDelta,
+      ),
+      RNCamera(
+        center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
+        zoom = cameraPosition.zoom.toDouble(),
+        bearing = cameraPosition.bearing.toDouble(),
+        tilt = cameraPosition.tilt.toDouble(),
+      ),
+      isGesture,
+    )
+    lastSubmittedCameraPosition = cameraPosition
+  }
+
+  override fun onCameraIdle() {
+    val bounds = googleMap?.projection?.visibleRegion?.latLngBounds
+    val cameraPosition = googleMap?.cameraPosition
+
+    if (bounds == null || cameraPosition == null) {
+      return
+    }
+    val isGesture = GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE == cameraMoveReason
+
+    val latDelta = bounds.northeast.latitude - bounds.southwest.latitude
+    val lngDelta = bounds.northeast.longitude - bounds.southwest.longitude
+
+    onCameraChangeComplete?.invoke(
+      RNRegion(
+        center = RNLatLng(bounds.center.latitude, bounds.center.longitude),
+        latitudeDelta = latDelta,
+        longitudeDelta = lngDelta,
+      ),
+      RNCamera(
+        center = RNLatLng(cameraPosition.target.latitude, cameraPosition.target.longitude),
+        zoom = cameraPosition.zoom.toDouble(),
+        bearing = cameraPosition.bearing.toDouble(),
+        tilt = cameraPosition.tilt.toDouble(),
+      ),
+      isGesture,
+    )
+  }
+
+  @SuppressLint("PotentialBehaviorOverride")
+  override fun onMapReady(map: GoogleMap) {
+    googleMap = map
+    googleMap?.setOnMapLoadedCallback {
+      googleMap?.setOnCameraMoveStartedListener(this)
+      googleMap?.setOnCameraMoveListener(this)
+      googleMap?.setOnCameraIdleListener(this)
+      googleMap?.setOnMarkerClickListener(this)
+      googleMap?.setOnMapClickListener(this)
+    }
+    initLocationCallbacks()
+    applyPending()
+
+    onMapReady?.invoke(true)
+  }
+
+  fun initLocationCallbacks() {
+    locationHandler.onUpdate = { location ->
+      // / only the coordinated are relevant right now
+      if (lastSubmittedLocation?.latitude != location.latitude || lastSubmittedLocation?.longitude != location.longitude ||
+        lastSubmittedLocation?.bearing != location.bearing
+      ) {
+        onLocationUpdate?.invoke(
+          RNLocation(
+            RNLatLng(location.latitude, location.longitude),
+            location.bearing.toDouble(),
+          ),
+        )
+      }
+      lastSubmittedLocation = location
+    }
+
+    locationHandler.onError = { error ->
+      onLocationError?.invoke(error)
+    }
+    locationHandler.start()
+  }
+
+  fun applyPending() {
+    onUi {
+      googleMap?.setPadding(
+        pendingMapPadding.left.dpToPx().toInt(),
+        pendingMapPadding.top.dpToPx().toInt(),
+        pendingMapPadding.right.dpToPx().toInt(),
+        pendingMapPadding.bottom.dpToPx().toInt(),
+      )
+
+      pendingInitialCamera.let {
+        googleMap?.moveCamera(
+          CameraUpdateFactory.newCameraPosition(
+            it,
+          ),
+        )
+      }
+
+      googleMap?.isBuildingsEnabled = pendingBuildingEnabled
+      googleMap?.isTrafficEnabled = pendingTrafficEnabled
+      googleMap?.setMapStyle(pendingCustomMapStyle)
+      googleMap?.mapColorScheme = pendingUserInterfaceStyle
+      googleMap?.setMinZoomPreference(pendingMinZoomLevel.toFloat())
+      googleMap?.setMaxZoomPreference(pendingMaxZoomLevel.toFloat())
+    }
+
+    if (pendingMarkers.isNotEmpty()) {
+      pendingMarkers.forEach { (id, opts) ->
+        internalAddMarker(id, opts)
+      }
+      pendingMarkers.clear()
+    }
+
+    if (pendingPolylines.isNotEmpty()) {
+      pendingPolylines.forEach { (id, opts) ->
+        internalAddPolyline(id, opts)
+      }
+      pendingPolylines.clear()
+    }
+
+    if (pendingPolygons.isNotEmpty()) {
+      pendingPolygons.forEach { (id, opts) ->
+        internalAddPolygon(id, opts)
+      }
+      pendingPolygons.clear()
+    }
+  }
+
+  var buildingEnabled: Boolean
+    get() = googleMap?.isBuildingsEnabled ?: pendingBuildingEnabled
+    set(value) {
+      pendingBuildingEnabled = value
+      onUi {
+        googleMap?.isBuildingsEnabled = value
+      }
+    }
+
+  var trafficEnabled: Boolean
+    get() = googleMap?.isTrafficEnabled ?: pendingTrafficEnabled
+    set(value) {
+      pendingTrafficEnabled = value
+      onUi {
+        googleMap?.isTrafficEnabled = value
+      }
+    }
+
+  var customMapStyle: MapStyleOptions?
+    get() = pendingCustomMapStyle
+    set(value) {
+      pendingCustomMapStyle = value
+      onUi {
+        googleMap?.setMapStyle(value)
+      }
+    }
+
+  var initialCamera: CameraPosition
+    get() = pendingInitialCamera
+    set(value) {
+      pendingInitialCamera = value
+    }
+
+  var userInterfaceStyle: Int
+    get() = pendingUserInterfaceStyle
+    set(value) {
+      pendingUserInterfaceStyle = value
+      onUi {
+        googleMap?.mapColorScheme = value
+      }
+    }
+
+  var minZoomLevel: Double
+    get() = pendingMinZoomLevel
+    set(value) {
+      pendingMinZoomLevel = value
+      onUi {
+        googleMap?.setMinZoomPreference(value.toFloat())
+      }
+    }
+
+  var maxZoomLevel: Double
+    get() = pendingMaxZoomLevel
+    set(value) {
+      pendingMaxZoomLevel = value
+      onUi {
+        googleMap?.setMaxZoomPreference(value.toFloat())
+      }
+    }
+
+  var mapPadding: RNMapPadding
+    get() = pendingMapPadding
+    set(value) {
+      pendingMapPadding = value
+      onUi {
+        googleMap?.setPadding(
+          value.left.dpToPx().toInt(),
+          value.top.dpToPx().toInt(),
+          value.right.dpToPx().toInt(),
+          value.bottom.dpToPx().toInt(),
+        )
+      }
+    }
+
+  var onMapError: ((RNMapErrorCode) -> Unit)? = null
+  var onMapReady: ((Boolean) -> Unit)? = null
+  var onLocationUpdate: ((RNLocation) -> Unit)? = null
+  var onLocationError: ((RNLocationErrorCode) -> Unit)? = null
+  var onMapPress: ((RNLatLng) -> Unit)? = null
+  var onMarkerPress: ((String) -> Unit)? = null
+  var onCameraChangeStart: ((RNRegion, RNCamera, Boolean) -> Unit)? = null
+  var onCameraChange: ((RNRegion, RNCamera, Boolean) -> Unit)? = null
+  var onCameraChangeComplete: ((RNRegion, RNCamera, Boolean) -> Unit)? = null
+
+  fun setCamera(
+    camera: RNCamera,
+    animated: Boolean,
+    durationMS: Int,
+  ) {
+    onUi {
+      val current = googleMap?.cameraPosition
+      if (current == null) {
+        return@onUi
+      }
+      val camPosBuilder =
+        CameraPosition.Builder(
+          current,
+        )
+
+      camera.center?.let {
+        camPosBuilder.target(
+          LatLng(
+            it.latitude,
+            it.longitude,
+          ),
+        )
+      }
+
+      camera.zoom?.let {
+        camPosBuilder.zoom(it.toFloat())
+      }
+      camera.bearing?.let {
+        camPosBuilder.bearing(it.toFloat())
+      }
+      camera.tilt?.let {
+        camPosBuilder.tilt(it.toFloat())
+      }
+
+      val camPos = camPosBuilder.build()
+
+      val update = CameraUpdateFactory.newCameraPosition(camPos)
+
+      if (animated) {
+        googleMap?.animateCamera(update, durationMS, null)
+      } else {
+        googleMap?.moveCamera(update)
+      }
+    }
+  }
+
+  fun setCameraToCoordinates(
+    coordinates: Array<RNLatLng>,
+    padding: RNMapPadding,
+    animated: Boolean,
+    durationMS: Int,
+  ) {
+    if (coordinates.isEmpty()) {
+      return
+    }
+    onUi {
+      val builder = LatLngBounds.Builder()
+      coordinates.forEach { coord ->
+        builder.include(LatLng(coord.latitude, coord.longitude))
+      }
+      val bounds = builder.build()
+
+      val latSpan = bounds.northeast.latitude - bounds.southwest.latitude
+      val lngSpan = bounds.northeast.longitude - bounds.southwest.longitude
+
+      val latPerPixel = latSpan / height
+      val lngPerPixel = lngSpan / width
+
+      builder.include(
+        LatLng(
+          bounds.northeast.latitude + (padding.top.dpToPx() * latPerPixel),
+          bounds.northeast.longitude,
+        ),
+      )
+      builder.include(
+        LatLng(
+          bounds.southwest.latitude - (padding.bottom.dpToPx() * latPerPixel),
+          bounds.southwest.longitude,
+        ),
+      )
+      builder.include(
+        LatLng(
+          bounds.northeast.latitude,
+          bounds.northeast.longitude + (padding.right.dpToPx() * lngPerPixel),
+        ),
+      )
+      builder.include(
+        LatLng(
+          bounds.southwest.latitude,
+          bounds.southwest.longitude - (padding.left.dpToPx() * lngPerPixel),
+        ),
+      )
+
+      val paddedBounds = builder.build()
+
+      val adjustedWidth = (width - padding.left.dpToPx() - padding.right.dpToPx()).toInt()
+      val adjustedHeight = (height - padding.top.dpToPx() - padding.bottom.dpToPx()).toInt()
+
+      val update =
+        CameraUpdateFactory.newLatLngBounds(
+          paddedBounds,
+          adjustedWidth,
+          adjustedHeight,
+          0,
+        )
+      if (animated) {
+        googleMap?.animateCamera(update, durationMS, null)
+      } else {
+        googleMap?.moveCamera(update)
+      }
+    }
+  }
+
+  fun addMarker(
+    id: String,
+    opts: MarkerOptions,
+  ) {
+    if (googleMap == null) {
+      pendingMarkers.add(id to opts)
+      return
+    }
+
+    onUi {
+      markersById.remove(id)?.remove()
+    }
+    internalAddMarker(id, opts)
+  }
+
+  private fun internalAddMarker(
+    id: String,
+    opts: MarkerOptions,
+  ) {
+    onUi {
+      val marker =
+        googleMap?.addMarker(opts).also {
+          it?.tag = id
+        }
+      if (marker != null) {
+        markersById[id] = marker
+      }
+    }
+  }
+
+  fun updateMarker(
+    id: String,
+    block: (Marker) -> Unit,
+  ) {
+    val marker = markersById[id] ?: return
+    onUi {
+      block(marker)
+    }
+  }
+
+  fun removeMarker(id: String) {
+    onUi {
+      val marker = markersById.remove(id)
+      marker?.remove()
+    }
+  }
+
+  fun clearMarkers() {
+    onUi {
+      markersById.values.forEach { it.remove() }
+    }
+    markersById.clear()
+    pendingMarkers.clear()
+  }
+
+  fun addPolyline(
+    id: String,
+    opts: PolylineOptions,
+  ) {
+    if (googleMap == null) {
+      pendingPolylines.add(id to opts)
+      return
+    }
+    onUi {
+      polylinesById.remove(id)?.remove()
+    }
+    internalAddPolyline(id, opts)
+  }
+
+  private fun internalAddPolyline(
+    id: String,
+    opts: PolylineOptions,
+  ) {
+    onUi {
+      val polyline =
+        googleMap?.addPolyline(opts).also {
+          it?.tag = id
+        }
+      if (polyline != null) {
+        polylinesById[id] = polyline
+      }
+    }
+  }
+
+  fun updatePolyline(
+    id: String,
+    block: (Polyline) -> Unit,
+  ) {
+    val pl = polylinesById[id] ?: return
+    onUi {
+      block(pl)
+    }
+  }
+
+  fun removePolyline(id: String) {
+    onUi {
+      polylinesById.remove(id)?.remove()
+    }
+  }
+
+  fun clearPolylines() {
+    onUi {
+      polylinesById.values.forEach { it.remove() }
+    }
+    polylinesById.clear()
+    pendingPolylines.clear()
+  }
+
+  fun addPolygon(
+    id: String,
+    opts: PolygonOptions,
+  ) {
+    if (googleMap == null) {
+      pendingPolygons.add(id to opts)
+      return
+    }
+
+    onUi {
+      polygonsById.remove(id)?.remove()
+    }
+    internalAddPolygon(id, opts)
+  }
+
+  private fun internalAddPolygon(
+    id: String,
+    opts: PolygonOptions,
+  ) {
+    onUi {
+      val polygon =
+        googleMap?.addPolygon(opts).also {
+          it?.tag = id
+        }
+      if (polygon != null) {
+        polygonsById[id] = polygon
+      }
+    }
+  }
+
+  fun updatePolygon(
+    id: String,
+    block: (Polygon) -> Unit,
+  ) {
+    val polygon = polygonsById[id] ?: return
+    onUi {
+      block(polygon)
+    }
+  }
+
+  fun removePolygon(id: String) {
+    onUi {
+      polygonsById.remove(id)?.remove()
+    }
+  }
+
+  fun clearPolygons() {
+    onUi {
+      polygonsById.values.forEach { it.remove() }
+    }
+    polygonsById.clear()
+    pendingPolygons.clear()
+  }
+
+  fun clearAll() {
+    onUi {
+      markerOptions.cancelAllJobs()
+      clearMarkers()
+      clearPolylines()
+      clearPolygons()
+      locationHandler.stop()
+      googleMap?.apply {
+        setOnCameraMoveStartedListener(null)
+        setOnCameraMoveListener(null)
+        setOnCameraIdleListener(null)
+        setOnMarkerClickListener(null)
+        setOnMapClickListener(null)
+      }
+      this@GoogleMapsNitroViewImpl.onDestroy()
+      googleMap = null
+      reactContext.removeLifecycleEventListener(this)
+    }
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+    // / setPadding issue
+    post {
+      measure(
+        MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+      )
+      layout(left, top, right, bottom)
+    }
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    locationHandler.start()
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    locationHandler.stop()
+  }
+
+  override fun onHostResume() {
+    onUi {
+      locationHandler.start()
+      this@GoogleMapsNitroViewImpl.onResume()
+    }
+  }
+
+  override fun onHostPause() {
+    onUi {
+      locationHandler.stop()
+      this@GoogleMapsNitroViewImpl.onPause()
+    }
+  }
+
+  override fun onHostDestroy() {
+    clearAll()
+  }
+
+  override fun onMarkerClick(marker: Marker): Boolean {
+    onMarkerPress?.invoke(marker.tag?.toString() ?: "unknown")
+    return true
+  }
+
+  override fun onMapClick(coordinates: LatLng) {
+    onMapPress?.invoke(
+      RNLatLng(coordinates.latitude, coordinates.longitude),
+    )
+  }
+}
+
+private inline fun onUi(crossinline block: () -> Unit) {
+  if (UiThreadUtil.isOnUiThread()) {
+    block()
+  } else {
+    UiThreadUtil.runOnUiThread { block() }
+  }
+}