react-native-google-maps-plus 0.1.0 → 1.0.0-dev.1

package/android/src/main/java/com/rngooglemapsplus/RNGoogleMapsPlusView.kt

@@ -0,0 +1,364 @@
+package com.rngooglemapsplus
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.gms.maps.model.CameraPosition
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.MapColorScheme
+import com.google.android.gms.maps.model.MapStyleOptions
+import com.margelo.nitro.core.Promise
+
+@DoNotStrip
+class RNGoogleMapsPlusView(
+  val context: ThemedReactContext,
+) : HybridRNGoogleMapsPlusViewSpec() {
+  private var currentCustomMapStyle: String? = null
+  private var permissionHandler = PermissionHandler(context)
+  private var locationHandler = LocationHandler(context)
+  private var playServiceHandler = PlayServicesHandler(context)
+
+  private val markerOptions = MarkerOptions()
+  private val polylineOptions = MapPolylineOptions()
+  private val polygonOptions = MapPolygonOptions()
+  private val circleOptions = MapCircleOptions()
+
+  override val view =
+    GoogleMapsViewImpl(context, locationHandler, playServiceHandler, markerOptions)
+
+  override var initialProps: RNInitialProps? = null
+    set(value) {
+      view.initMapView(
+        value?.mapId,
+        value?.liteMode,
+        mapCameraToCameraPosition(value?.initialCamera),
+      )
+    }
+
+  override var buildingEnabled: Boolean? = null
+    set(value) {
+      view.buildingEnabled = value
+    }
+
+  override var trafficEnabled: Boolean? = null
+    set(value) {
+      view.trafficEnabled = value
+    }
+
+  override var customMapStyle: String? = null
+    set(value) {
+      currentCustomMapStyle = value
+      value?.let {
+        view.customMapStyle = MapStyleOptions(it)
+      }
+    }
+
+  override var userInterfaceStyle: RNUserInterfaceStyle? = null
+    set(value) {
+      view.userInterfaceStyle = userInterfaceStyleToMapColorScheme(value)
+    }
+
+  override var minZoomLevel: Double? = null
+    set(value) {
+      view.minZoomLevel = value
+    }
+
+  override var maxZoomLevel: Double? = null
+    set(value) {
+      view.maxZoomLevel = value
+    }
+
+  override var mapPadding: RNMapPadding? = null
+    set(value) {
+      view.mapPadding = value
+    }
+
+  override var mapType: RNMapType? = null
+    set(value) {
+      value?.let {
+        view.mapType = it.value
+      }
+    }
+
+  override var markers: Array<RNMarker>? = null
+    set(value) {
+      val prevById = field?.associateBy { it.id } ?: emptyMap()
+      val nextById = value?.associateBy { it.id } ?: emptyMap()
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        markerOptions.cancelIconJob(id)
+        view.removeMarker(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          markerOptions.buildIconAsync(id, next) { icon ->
+            view.addMarker(
+              id,
+              markerOptions.build(next, icon),
+            )
+          }
+        } else if (!prev.markerEquals(next)) {
+          view.updateMarker(id) { m ->
+            onUi {
+              m.position =
+                LatLng(
+                  next.coordinate.latitude,
+                  next.coordinate.longitude,
+                )
+              next.zIndex?.let { m.zIndex = it.toFloat() } ?: run {
+                m.zIndex = 0f
+              }
+
+              if (!prev.markerStyleEquals(next)) {
+                markerOptions.buildIconAsync(id, next) { icon ->
+                  m.setIcon(icon)
+                }
+              }
+              m.setAnchor(
+                (next.anchor?.x ?: 0.5).toFloat(),
+                (next.anchor?.y ?: 0.5).toFloat(),
+              )
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var polylines: Array<RNPolyline>? = null
+    set(value) {
+      val prevById = field?.associateBy { it.id } ?: emptyMap()
+      val nextById = value?.associateBy { it.id } ?: emptyMap()
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        view.removePolyline(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          view.addPolyline(id, polylineOptions.buildPolylineOptions(next))
+        } else if (!prev.polylineEquals(next)) {
+          view.updatePolyline(id) { gms ->
+            onUi {
+              gms.points =
+                next.coordinates.map {
+
+                  LatLng(it.latitude, it.longitude)
+                }
+              next.width?.let { gms.width = it.dpToPx() }
+              next.lineCap?.let {
+                val cap = polylineOptions.mapLineCap(it)
+                gms.startCap = cap
+                gms.endCap = cap
+              }
+              next.lineJoin?.let { gms.jointType = polylineOptions.mapLineJoin(it) }
+              next.color?.let { gms.color = it.toColor() }
+              next.zIndex?.let { gms.zIndex = it.toFloat() }
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var polygons: Array<RNPolygon>? = null
+    set(value) {
+      val prevById = field?.associateBy { it.id } ?: emptyMap()
+      val nextById = value?.associateBy { it.id } ?: emptyMap()
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        view.removePolygon(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          view.addPolygon(id, polygonOptions.buildPolygonOptions(next))
+        } else if (!prev.polygonEquals(next)) {
+          view.updatePolygon(id) { gmsPoly ->
+            onUi {
+              gmsPoly.points =
+                next.coordinates.map {
+                  com.google.android.gms.maps.model
+                    .LatLng(it.latitude, it.longitude)
+                }
+              next.fillColor?.let { gmsPoly.fillColor = it.toColor() }
+              next.strokeColor?.let { gmsPoly.strokeColor = it.toColor() }
+              next.strokeWidth?.let { gmsPoly.strokeWidth = it.dpToPx() }
+              next.zIndex?.let { gmsPoly.zIndex = it.toFloat() }
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var circles: Array<RNCircle>? = null
+    set(value) {
+      val prevById = field?.associateBy { it.id } ?: emptyMap()
+      val nextById = value?.associateBy { it.id } ?: emptyMap()
+
+      (prevById.keys - nextById.keys).forEach { id ->
+        view.removeCircle(id)
+      }
+
+      nextById.forEach { (id, next) ->
+        val prev = prevById[id]
+        if (prev == null) {
+          view.addCircle(id, circleOptions.buildCircleOptions(next))
+        } else if (!prev.circleEquals(next)) {
+          view.updateCircle(id) { gmsCircle ->
+            onUi {
+              gmsCircle.center = LatLng(next.center.latitude, next.center.longitude)
+              next.radius?.let { gmsCircle.radius = it }
+              next.strokeWidth?.let { gmsCircle.strokeWidth = it.dpToPx() }
+              next.strokeColor?.let { gmsCircle.strokeColor = it.toColor() }
+              next.fillColor?.let { gmsCircle.fillColor = it.toColor() }
+              next.zIndex?.let { gmsCircle.zIndex = it.toFloat() } ?: run { gmsCircle.zIndex = 0f }
+            }
+          }
+        }
+      }
+      field = value
+    }
+
+  override var onMapError: ((RNMapErrorCode) -> Unit)? = null
+    set(cb) {
+      view.onMapError = cb
+    }
+
+  override var onMapReady: ((Boolean) -> Unit)? = null
+    set(cb) {
+      view.onMapReady = cb
+    }
+  override var onLocationUpdate: ((RNLocation) -> Unit)? = null
+    set(cb) {
+      view.onLocationUpdate = cb
+    }
+
+  override var onLocationError: ((RNLocationErrorCode) -> Unit)? = null
+    set(cb) {
+      view.onLocationError = cb
+    }
+
+  override var onMapPress: ((RNLatLng) -> Unit)? = null
+    set(cb) {
+      view.onMapPress = cb
+    }
+
+  override var onMarkerPress: ((String) -> Unit)? = null
+    set(cb) {
+      view.onMarkerPress = cb
+    }
+
+  override var onPolylinePress: ((String) -> Unit)? = null
+    set(cb) {
+      view.onPolylinePress = cb
+    }
+
+  override var onPolygonPress: ((String) -> Unit)? = null
+    set(cb) {
+      view.onPolygonPress = cb
+    }
+
+  override var onCirclePress: ((String) -> Unit)? = null
+    set(cb) {
+      view.onCirclePress = cb
+    }
+
+  override var onCameraChangeStart: ((RNRegion, RNCamera, Boolean) -> Unit)? = null
+    set(cb) {
+      view.onCameraChangeStart = cb
+    }
+
+  override var onCameraChange: ((RNRegion, RNCamera, Boolean) -> Unit)? = null
+    set(cb) {
+      view.onCameraChange = cb
+    }
+
+  override var onCameraChangeComplete: ((RNRegion, RNCamera, Boolean) -> Unit)? = null
+    set(cb) {
+      view.onCameraChangeComplete = cb
+    }
+
+  override fun setCamera(
+    camera: RNCamera,
+    animated: Boolean?,
+    durationMS: Double?,
+  ) {
+    view.setCamera(camera, animated == true, durationMS?.toInt() ?: 3000)
+  }
+
+  override fun setCameraToCoordinates(
+    coordinates: Array<RNLatLng>,
+    padding: RNMapPadding?,
+    animated: Boolean?,
+    durationMS: Double?,
+  ) {
+    view.setCameraToCoordinates(
+      coordinates,
+      padding = padding ?: RNMapPadding(0.0, 0.0, 0.0, 0.0),
+      animated == true,
+      durationMS?.toInt() ?: 3000,
+    )
+  }
+
+  override fun showLocationDialog() {
+    locationHandler.showLocationDialog()
+  }
+
+  override fun openLocationSettings() {
+    locationHandler.openLocationSettings()
+  }
+
+  override fun requestLocationPermission(): Promise<RNLocationPermissionResult> = permissionHandler.requestLocationPermission()
+
+  override fun isGooglePlayServicesAvailable(): Boolean = playServiceHandler.isPlayServicesAvailable()
+
+  fun userInterfaceStyleToMapColorScheme(value: RNUserInterfaceStyle?): Int? {
+    value ?: return null
+    return when (value) {
+      RNUserInterfaceStyle.LIGHT -> {
+        MapColorScheme.LIGHT
+      }
+
+      RNUserInterfaceStyle.DARK -> {
+        MapColorScheme.DARK
+      }
+
+      RNUserInterfaceStyle.DEFAULT -> {
+        MapColorScheme.FOLLOW_SYSTEM
+      }
+    }
+  }
+
+  fun mapCameraToCameraPosition(camera: RNCamera?): CameraPosition? {
+    camera ?: return null
+    val builder = CameraPosition.builder()
+    camera.center?.let {
+      builder.target(
+        com.google.android.gms.maps.model.LatLng(
+          camera.center.latitude,
+          camera.center.longitude,
+        ),
+      )
+    }
+    camera.zoom?.let { builder.zoom(it.toFloat()) }
+    camera.bearing?.let { builder.bearing(it.toFloat()) }
+    camera.tilt?.let { builder.tilt(it.toFloat()) }
+
+    return builder.build()
+  }
+}
+
+private inline fun onUi(crossinline block: () -> Unit) {
+  if (UiThreadUtil.isOnUiThread()) {
+    block()
+  } else {
+    UiThreadUtil.runOnUiThread { block() }
+  }
+}

package/ios/Color.swift

@@ -0,0 +1,109 @@
+extension String {
+  func toUIColor(default defaultColor: UIColor = .clear) -> UIColor {
+    return UIColor.fromCssString(self) ?? defaultColor
+  }
+}
+
+extension UIColor {
+  static func fromCssString(_ s: String) -> UIColor? {
+    let str = s.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    if str.hasPrefix("#") { return Self.fromHex(str) }
+    if str.hasPrefix("rgb") { return Self.fromRGBFunction(str) }
+    if str.hasPrefix("hsl") { return Self.fromHSLFunction(str) }
+    if let named = namedColors[str] { return named }
+    return nil
+  }
+
+  private static let namedColors: [String: UIColor] = [
+    "red": .red, "green": .green, "blue": .blue,
+    "black": .black, "white": .white, "gray": .gray, "grey": .gray,
+    "yellow": .yellow, "orange": .orange, "purple": .purple,
+    "cyan": .cyan, "aqua": .cyan, "magenta": .magenta, "fuchsia": .magenta,
+    "brown": .brown, "clear": .clear, "transparent": .clear
+  ]
+
+  private static func fromHex(_ hex: String) -> UIColor? {
+    var sanitized = hex.replacingOccurrences(of: "#", with: "")
+    if sanitized.count == 3 || sanitized.count == 4 {
+      sanitized = sanitized.map { "\($0)\($0)" }.joined()
+    }
+    if sanitized.count == 6 { sanitized += "ff" }
+    guard sanitized.count == 8, let rgba = UInt32(sanitized, radix: 16) else {
+      return nil
+    }
+    let r = CGFloat((rgba & 0xff00_0000) >> 24) / 255.0
+    let g = CGFloat((rgba & 0x00ff_0000) >> 16) / 255.0
+    let b = CGFloat((rgba & 0x0000_ff00) >> 8) / 255.0
+    let a = CGFloat(rgba & 0x0000_00ff) / 255.0
+    return UIColor(red: r, green: g, blue: b, alpha: a)
+  }
+
+  private static func fromRGBFunction(_ s: String) -> UIColor? {
+    let nums =
+      s
+        .replacingOccurrences(of: "rgba", with: "")
+        .replacingOccurrences(of: "rgb", with: "")
+        .replacingOccurrences(of: "(", with: "")
+        .replacingOccurrences(of: ")", with: "")
+        .split(separator: ",")
+        .map { $0.trimmingCharacters(in: .whitespaces) }
+
+    guard nums.count == 3 || nums.count == 4,
+          let r = Double(nums[0]),
+          let g = Double(nums[1]),
+          let b = Double(nums[2])
+    else { return nil }
+    let a = (nums.count == 4) ? (Double(nums[3]) ?? 1.0) : 1.0
+    return UIColor(
+      red: CGFloat(r / 255.0),
+      green: CGFloat(g / 255.0),
+      blue: CGFloat(b / 255.0),
+      alpha: CGFloat(a)
+    )
+  }
+
+  private static func fromHSLFunction(_ s: String) -> UIColor? {
+    let parts =
+      s
+        .replacingOccurrences(of: "hsla", with: "")
+        .replacingOccurrences(of: "hsl", with: "")
+        .replacingOccurrences(of: "(", with: "")
+        .replacingOccurrences(of: ")", with: "")
+        .replacingOccurrences(of: "%", with: "")
+        .split(separator: ",")
+        .map { $0.trimmingCharacters(in: .whitespaces) }
+
+    guard parts.count == 3 || parts.count == 4,
+          let h = Double(parts[0]),
+          let sPerc = Double(parts[1]),
+          let lPerc = Double(parts[2])
+    else { return nil }
+
+    let a = (parts.count == 4) ? (Double(parts[3]) ?? 1.0) : 1.0
+    let s = sPerc / 100.0
+    let l = lPerc / 100.0
+
+    let c = (1 - Swift.abs(2 * l - 1)) * s
+    let x = c * (1 - Swift.abs((h / 60).truncatingRemainder(dividingBy: 2) - 1))
+    let m = l - c / 2
+
+    // swiftlint:disable:next large_tuple
+    let (r1, g1, b1): (Double, Double, Double)
+    switch h {
+    case 0..<60: (r1, g1, b1) = (c, x, 0)
+    case 60..<120: (r1, g1, b1) = (x, c, 0)
+    case 120..<180: (r1, g1, b1) = (0, c, x)
+    case 180..<240: (r1, g1, b1) = (0, x, c)
+    case 240..<300: (r1, g1, b1) = (x, 0, c)
+    case 300..<360: (r1, g1, b1) = (c, 0, x)
+    default: (r1, g1, b1) = (0, 0, 0)
+    }
+    return UIColor(
+      red: CGFloat(r1 + m),
+      green: CGFloat(g1 + m),
+      blue: CGFloat(b1 + m),
+      alpha: CGFloat(a)
+    )
+  }
+
+}