expo-gaode-map 0.1.1 → 0.1.2

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/CircleManager.kt

@@ -0,0 +1,49 @@
+package qiuxiang.amap3d.map_view
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import qiuxiang.amap3d.toLatLng
+import qiuxiang.amap3d.toPx
+
+@Suppress("unused")
+internal class CircleManager : SimpleViewManager<Circle>() {
+  override fun getName(): String {
+    return "AMapCircle"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): Circle {
+    return Circle(reactContext)
+  }
+
+  @ReactProp(name = "center")
+  fun setCenter(circle: Circle, center: ReadableMap) {
+    circle.center = center.toLatLng()
+  }
+
+  @ReactProp(name = "radius")
+  fun setRadius(circle: Circle, radius: Double) {
+    circle.radius = radius
+  }
+
+  @ReactProp(name = "fillColor", customType = "Color")
+  fun setFillColor(circle: Circle, fillColor: Int) {
+    circle.fillColor = fillColor
+  }
+
+  @ReactProp(name = "strokeColor", customType = "Color")
+  fun setStrokeColor(circle: Circle, strokeColor: Int) {
+    circle.strokeColor = strokeColor
+  }
+
+  @ReactProp(name = "strokeWidth")
+  fun setStrokeWidth(circle: Circle, strokeWidth: Float) {
+    circle.strokeWidth = strokeWidth.toPx().toFloat()
+  }
+
+  @ReactProp(name = "zIndex")
+  fun setIndex(circle: Circle, zIndex: Float) {
+    circle.zIndex = zIndex
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/HeatMap.kt

@@ -0,0 +1,32 @@
+package qiuxiang.amap3d.map_view
+
+import android.content.Context
+import com.amap.api.maps.AMap
+import com.amap.api.maps.model.HeatmapTileProvider
+import com.amap.api.maps.model.LatLng
+import com.amap.api.maps.model.TileOverlay
+import com.amap.api.maps.model.TileOverlayOptions
+import com.facebook.react.views.view.ReactViewGroup
+
+class HeatMap(context: Context) : ReactViewGroup(context), Overlay {
+  private var overlay: TileOverlay? = null
+  var data: List<LatLng> = emptyList()
+  var opacity: Double = 0.6
+  var radius: Int = 12
+
+  override fun add(map: AMap) {
+    overlay = map.addTileOverlay(
+      TileOverlayOptions().tileProvider(
+        HeatmapTileProvider.Builder()
+          .data(data)
+          .radius(radius)
+          .transparency(opacity)
+          .build()
+      )
+    )
+  }
+
+  override fun remove() {
+    overlay?.remove()
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/HeatMapManager.kt

@@ -0,0 +1,33 @@
+package qiuxiang.amap3d.map_view
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import qiuxiang.amap3d.toLatLngList
+
+@Suppress("unused")
+internal class HeatMapManager : SimpleViewManager<HeatMap>() {
+  override fun getName(): String {
+    return "AMapHeatMap"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): HeatMap {
+    return HeatMap(reactContext)
+  }
+
+  @ReactProp(name = "data")
+  fun setData(heatMap: HeatMap, data: ReadableArray) {
+    heatMap.data = data.toLatLngList()
+  }
+
+  @ReactProp(name = "radius")
+  fun setRadius(heatMap: HeatMap, radius: Int) {
+    heatMap.radius = radius
+  }
+
+  @ReactProp(name = "opacity")
+  fun setOpacity(heatMap: HeatMap, opacity: Double) {
+    heatMap.opacity = opacity
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/MapView.kt

@@ -0,0 +1,190 @@
+package qiuxiang.amap3d.map_view
+
+import android.annotation.SuppressLint
+import android.graphics.Color
+import android.view.View
+import com.amap.api.maps.AMap
+import com.amap.api.maps.CameraUpdateFactory
+import com.amap.api.maps.TextureMapView
+import com.amap.api.maps.model.BitmapDescriptorFactory
+import com.amap.api.maps.model.CameraPosition
+import com.amap.api.maps.model.LatLng
+import com.amap.api.maps.model.Marker
+import com.amap.api.maps.model.MyLocationStyle
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import qiuxiang.amap3d.R
+import qiuxiang.amap3d.getFloat
+import qiuxiang.amap3d.toJson
+import qiuxiang.amap3d.toLatLng
+import qiuxiang.amap3d.toPoint
+
+
+@SuppressLint("ViewConstructor")
+class MapView(context: ThemedReactContext) : TextureMapView(context) {
+  @Suppress("Deprecation")
+  private val eventEmitter =
+    context.getJSModule(com.facebook.react.uimanager.events.RCTEventEmitter::class.java)
+  private val markerMap = HashMap<String, qiuxiang.amap3d.map_view.Marker>()
+  private val polylineMap = HashMap<String, Polyline>()
+  private var initialCameraPosition: ReadableMap? = null
+  private var locationStyle: MyLocationStyle
+  private var currentLocation: LatLng? = null
+
+  init {
+    super.onCreate(null)
+
+    locationStyle = MyLocationStyle()
+    locationStyle.myLocationType(MyLocationStyle.LOCATION_TYPE_LOCATE)
+    locationStyle.myLocationIcon(BitmapDescriptorFactory.fromResource(R.drawable.positio_icon))
+    locationStyle.strokeColor(Color.TRANSPARENT)
+    locationStyle.radiusFillColor(Color.TRANSPARENT)
+    map.myLocationStyle = locationStyle
+
+    map.setOnMapLoadedListener { emit(id, "onLoad") }
+    map.setOnMapClickListener { latLng -> emit(id, "onPress", latLng.toJson()) }
+    map.setOnPOIClickListener { poi -> emit(id, "onPressPoi", poi.toJson()) }
+    map.setOnMapLongClickListener { latLng -> emit(id, "onLongPress", latLng.toJson()) }
+    map.setOnPolylineClickListener { polyline -> emit(polylineMap[polyline.id]?.id, "onPress") }
+
+    map.setOnMarkerClickListener { marker ->
+      markerMap[marker.id]?.let { emit(it.id, "onPress") }
+      true
+    }
+
+    map.setOnMarkerDragListener(object : AMap.OnMarkerDragListener {
+      override fun onMarkerDragStart(marker: Marker) {
+        emit(markerMap[marker.id]?.id, "onDragStart")
+      }
+
+      override fun onMarkerDrag(marker: Marker) {
+        emit(markerMap[marker.id]?.id, "onDrag")
+      }
+
+      override fun onMarkerDragEnd(marker: Marker) {
+        emit(markerMap[marker.id]?.id, "onDragEnd", marker.position.toJson())
+      }
+    })
+
+    map.setOnCameraChangeListener(object : AMap.OnCameraChangeListener {
+      override fun onCameraChangeFinish(position: CameraPosition) {
+        emit(id, "onCameraIdle", Arguments.createMap().apply {
+          putMap("cameraPosition", position.toJson())
+          putMap("latLngBounds", map.projection.visibleRegion.latLngBounds.toJson())
+        })
+      }
+
+      override fun onCameraChange(position: CameraPosition) {
+        emit(id, "onCameraMove", Arguments.createMap().apply {
+          putMap("cameraPosition", position.toJson())
+          putMap("latLngBounds", map.projection.visibleRegion.latLngBounds.toJson())
+        })
+      }
+    })
+
+    map.setOnMultiPointClickListener { item ->
+      item.customerId.split("_").let {
+        emit(
+          it[0].toInt(),
+          "onPress",
+          Arguments.createMap().apply { putInt("index", it[1].toInt()) },
+        )
+      }
+      false
+    }
+
+    map.setOnMyLocationChangeListener {
+      if (it.time > 0) {
+        emit(id, "onLocation", it.toJson())
+        currentLocation = LatLng(it.latitude, it.longitude)
+      }
+    }
+  }
+
+  fun emit(id: Int?, event: String, data: WritableMap = Arguments.createMap()) {
+    @Suppress("Deprecation")
+    id?.let { eventEmitter.receiveEvent(it, event, data) }
+  }
+
+  fun add(child: View) {
+    if (child is Overlay) {
+      child.add(map)
+      if (child is qiuxiang.amap3d.map_view.Marker) {
+        markerMap[child.marker?.id!!] = child
+      }
+      if (child is Polyline) {
+        polylineMap[child.polyline?.id!!] = child
+      }
+    }
+  }
+
+  fun remove(child: View) {
+    if (child is Overlay) {
+      child.remove()
+      if (child is qiuxiang.amap3d.map_view.Marker) {
+        markerMap.remove(child.marker?.id)
+      }
+      if (child is Polyline) {
+        polylineMap.remove(child.polyline?.id)
+      }
+    }
+  }
+
+  private val animateCallback = object : AMap.CancelableCallback {
+    override fun onCancel() {}
+    override fun onFinish() {}
+  }
+
+  fun moveCamera(args: ReadableArray?) {
+    val current = map.cameraPosition
+    val position = args?.getMap(0)!!
+    val target = position.getMap("target")?.toLatLng() ?: current.target
+    val zoom = position.getFloat("zoom") ?: current.zoom
+    val tilt = position.getFloat("tilt") ?: current.tilt
+    val bearing = position.getFloat("bearing") ?: current.bearing
+    val cameraUpdate = CameraUpdateFactory.newCameraPosition(
+      CameraPosition(target, zoom, tilt, bearing)
+    )
+    map.animateCamera(cameraUpdate, args.getInt(1).toLong(), animateCallback)
+  }
+
+  fun setInitialCameraPosition(position: ReadableMap) {
+    if (initialCameraPosition == null) {
+      initialCameraPosition = position
+      moveCamera(Arguments.createArray().apply {
+        pushMap(Arguments.createMap().apply { merge(position) })
+        pushInt(0)
+      })
+    }
+  }
+
+  fun call(args: ReadableArray?) {
+    val id = args?.getDouble(0)!!
+    when (args.getString(1)) {
+      "getLatLng" -> callback(
+        id,
+        // @todo 暂时兼容 0.63
+        @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+        map.projection.fromScreenLocation(args.getMap(2)!!.toPoint()).toJson()
+      )
+    }
+  }
+
+  private fun callback(id: Double, data: Any) {
+    emit(this.id, "onCallback", Arguments.createMap().apply {
+      putDouble("id", id)
+      when (data) {
+        is WritableMap -> putMap("data", data)
+      }
+    })
+  }
+
+  fun moveToCurrentLocation(){
+    if (currentLocation != null) {
+      map.animateCamera(CameraUpdateFactory.newLatLngZoom(currentLocation, 16f));
+    }
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/MapViewManager.kt

@@ -0,0 +1,181 @@
+package qiuxiang.amap3d.map_view
+
+
+import android.view.View
+import com.amap.api.maps.CameraUpdateFactory
+import com.amap.api.maps.model.BitmapDescriptorFactory
+import com.amap.api.maps.model.MyLocationStyle
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import qiuxiang.amap3d.R
+import qiuxiang.amap3d.getEventTypeConstants
+import qiuxiang.amap3d.toLatLng
+
+
+@Suppress("unused")
+internal class MapViewManager : ViewGroupManager<MapView>() {
+  private val commands = mapOf(
+    "moveCamera" to { view: MapView, args: ReadableArray? -> view.moveCamera(args) },
+    "call" to { view: MapView, args: ReadableArray? -> view.call(args) },
+    "moveToCurrentLocation" to { view: MapView, args: ReadableArray? -> view.moveToCurrentLocation() },
+  )
+
+  override fun getName(): String {
+    return "AMapView"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): MapView {
+    return MapView(reactContext)
+  }
+
+  override fun onDropViewInstance(view: MapView) {
+    super.onDropViewInstance(view)
+    view.onDestroy()
+  }
+
+  override fun getCommandsMap(): Map<String, Int> {
+    return commands.keys.mapIndexed { index, key -> key to index }.toMap()
+  }
+
+  override fun receiveCommand(view: MapView, command: Int, args: ReadableArray?) {
+    commands.values.toList()[command](view, args)
+  }
+
+  override fun addView(mapView: MapView, child: View, index: Int) {
+    mapView.add(child)
+    super.addView(mapView, child, index)
+  }
+
+  override fun removeViewAt(parent: MapView, index: Int) {
+    parent.remove(parent.getChildAt(index))
+    super.removeViewAt(parent, index)
+  }
+
+  override fun getExportedCustomBubblingEventTypeConstants(): Map<String, Any> {
+    return getEventTypeConstants(
+      "onLoad",
+      "onPress",
+      "onPressPoi",
+      "onLongPress",
+      "onCameraMove",
+      "onCameraIdle",
+      "onLocation",
+      "onCallback",
+    )
+  }
+
+  @ReactProp(name = "initialCameraPosition")
+  fun setInitialCameraPosition(view: MapView, position: ReadableMap) {
+    view.setInitialCameraPosition(position)
+  }
+
+  @ReactProp(name = "myLocationEnabled")
+  fun setMyLocationEnabled(view: MapView, enabled: Boolean) {
+    view.map.isMyLocationEnabled = enabled
+
+  }
+
+  //自定义定位图标
+    @ReactProp(name = "myLocationIcon")
+  fun setMyLocationIcon(view: MapView, enabled: Boolean) {
+    var myLocationStyle: MyLocationStyle = view.map.myLocationStyle
+    myLocationStyle.apply {
+      myLocationIcon(BitmapDescriptorFactory.fromResource(R.drawable.positio_icon))
+    }
+    if (enabled){
+      view.map.myLocationStyle = myLocationStyle
+    }
+  }
+
+  @ReactProp(name = "indoorViewEnabled")
+  fun setIndoorViewEnabled(view: MapView, enabled: Boolean) {
+    view.map.showIndoorMap(enabled)
+  }
+
+  @ReactProp(name = "buildingsEnabled")
+  fun setBuildingsEnabled(view: MapView, enabled: Boolean) {
+    view.map.showBuildings(enabled)
+  }
+
+  @ReactProp(name = "compassEnabled")
+  fun setCompassEnabled(view: MapView, show: Boolean) {
+    view.map.uiSettings.isCompassEnabled = show
+  }
+
+  @ReactProp(name = "zoomControlsEnabled")
+  fun setZoomControlsEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isZoomControlsEnabled = enabled
+  }
+
+  @ReactProp(name = "scaleControlsEnabled")
+  fun setScaleControlsEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isScaleControlsEnabled = enabled
+  }
+
+  @ReactProp(name = "language")
+  fun setLanguage(view: MapView, language: String) {
+    view.map.setMapLanguage(language)
+  }
+
+  @ReactProp(name = "myLocationButtonEnabled")
+  fun setMyLocationButtonEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isMyLocationButtonEnabled = enabled
+  }
+
+  @ReactProp(name = "trafficEnabled")
+  fun setTrafficEnabled(view: MapView, enabled: Boolean) {
+    view.map.isTrafficEnabled = enabled
+  }
+
+  @ReactProp(name = "maxZoom")
+  fun setMaxZoom(view: MapView, zoomLevel: Float) {
+    view.map.maxZoomLevel = zoomLevel
+  }
+
+  @ReactProp(name = "minZoom")
+  fun setMinZoom(view: MapView, zoomLevel: Float) {
+    view.map.minZoomLevel = zoomLevel
+  }
+
+  @ReactProp(name = "mapType")
+  fun setMapType(view: MapView, mapType: Int) {
+    view.map.mapType = mapType + 1
+  }
+
+  @ReactProp(name = "zoomGesturesEnabled")
+  fun setZoomGesturesEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isZoomGesturesEnabled = enabled
+  }
+
+  @ReactProp(name = "scrollGesturesEnabled")
+  fun setScrollGesturesEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isScrollGesturesEnabled = enabled
+  }
+
+  @ReactProp(name = "rotateGesturesEnabled")
+  fun setRotateGesturesEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isRotateGesturesEnabled = enabled
+  }
+
+  @ReactProp(name = "tiltGesturesEnabled")
+  fun setTiltGesturesEnabled(view: MapView, enabled: Boolean) {
+    view.map.uiSettings.isTiltGesturesEnabled = enabled
+  }
+
+  @ReactProp(name = "cameraPosition")
+  fun setCameraPosition(view: MapView, center: ReadableMap) {
+    view.map.moveCamera(CameraUpdateFactory.changeLatLng(center.toLatLng()))
+  }
+
+  @ReactMethod
+  fun moveToCurrentLocation(view: MapView) {
+    UiThreadUtil.runOnUiThread {
+      view.moveToCurrentLocation()
+    }
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/Marker.kt

@@ -0,0 +1,102 @@
+package qiuxiang.amap3d.map_view
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import com.amap.api.maps.AMap
+import com.amap.api.maps.model.*
+import com.amap.api.maps.model.Marker
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.views.view.ReactViewGroup
+import qiuxiang.amap3d.fetchImage
+
+class Marker(context: Context) : ReactViewGroup(context), Overlay {
+  private var view: View? = null
+  private var icon: BitmapDescriptor? = null
+  private var anchorX: Float = 0.5f
+  private var anchorY: Float = 1f
+  var marker: Marker? = null
+
+  var position: LatLng? = null
+    set(value) {
+      field = value
+      marker?.position = value
+    }
+
+  var zIndex: Float = 0.0f
+    set(value) {
+      field = value
+      marker?.zIndex = value
+    }
+
+  var flat: Boolean = false
+    set(value) {
+      field = value
+      marker?.isFlat = value
+    }
+
+  var opacity: Float = 1f
+    set(value) {
+      field = value
+      marker?.alpha = value
+    }
+
+  var draggable: Boolean = false
+    set(value) {
+      field = value
+      marker?.isDraggable = value
+    }
+
+  fun updateIcon() {
+    view?.let {
+      if (it.width != 0 && it.height != 0) {
+        val bitmap = Bitmap.createBitmap(it.width, it.height, Bitmap.Config.ARGB_8888)
+        it.draw(Canvas(bitmap))
+        icon = BitmapDescriptorFactory.fromBitmap(bitmap)
+        marker?.setIcon(icon)
+      }
+    }
+  }
+
+  fun setAnchor(x: Double, y: Double) {
+    anchorX = x.toFloat()
+    anchorY = y.toFloat()
+    marker?.setAnchor(anchorX, anchorY)
+  }
+
+  override fun addView(child: View, index: Int) {
+    super.addView(child, index)
+    view = child
+    view?.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> updateIcon() }
+  }
+
+  fun setIcon(source: ReadableMap) {
+    fetchImage(source) {
+      icon = it
+      Handler(Looper.getMainLooper()).post {
+        marker?.setIcon(it)
+      }
+    }
+  }
+
+  override fun add(map: AMap) {
+    marker = map.addMarker(
+      MarkerOptions()
+        .setFlat(flat)
+        .icon(icon)
+        .alpha(opacity)
+        .draggable(draggable)
+        .position(position)
+        .anchor(anchorX, anchorY)
+        .zIndex(zIndex)
+        .infoWindowEnable(false)
+    )
+  }
+
+  override fun remove() {
+    marker?.destroy()
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/map_view/MarkerManager.kt

@@ -0,0 +1,78 @@
+package qiuxiang.amap3d.map_view
+
+import android.view.View
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import qiuxiang.amap3d.getEventTypeConstants
+import qiuxiang.amap3d.toLatLng
+
+@Suppress("unused")
+internal class MarkerManager : ViewGroupManager<Marker>() {
+  override fun getName(): String {
+    return "AMapMarker"
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): Marker {
+    return Marker(reactContext)
+  }
+
+  override fun addView(marker: Marker, view: View, index: Int) {
+    super.addView(marker, view, index)
+  }
+
+  override fun getExportedCustomBubblingEventTypeConstants(): Map<String, Any> {
+    return getEventTypeConstants("onPress", "onDrag", "onDragStart", "onDragEnd")
+  }
+
+  companion object {
+    const val update = 1
+  }
+
+  override fun getCommandsMap(): Map<String, Int> {
+    return mapOf("update" to update)
+  }
+
+  override fun receiveCommand(marker: Marker, commandId: Int, args: ReadableArray?) {
+    when (commandId) {
+      update -> marker.updateIcon()
+    }
+  }
+
+  @ReactProp(name = "latLng")
+  fun setLatLng(view: Marker, position: ReadableMap) {
+    view.position = position.toLatLng()
+  }
+
+  @ReactProp(name = "flat")
+  fun setFlat(marker: Marker, flat: Boolean) {
+    marker.flat = flat
+  }
+
+  @ReactProp(name = "opacity")
+  override fun setOpacity(marker: Marker, opacity: Float) {
+    marker.opacity = opacity
+  }
+
+  @ReactProp(name = "draggable")
+  fun setDraggable(marker: Marker, draggable: Boolean) {
+    marker.draggable = draggable
+  }
+
+  @ReactProp(name = "zIndex")
+  fun setIndex(marker: Marker, zIndex: Float) {
+    marker.zIndex = zIndex
+  }
+
+  @ReactProp(name = "anchor")
+  fun setAnchor(view: Marker, anchor: ReadableMap) {
+    view.setAnchor(anchor.getDouble("x"), anchor.getDouble("y"))
+  }
+
+  @ReactProp(name = "icon")
+  fun setIcon(view: Marker, icon: ReadableMap?) {
+    icon?.let { view.setIcon(it) }
+  }
+}