@evnydd0sf/react-native-amap3d-fix 3.2.4-fix.1

package/lib/android/build.gradle

@@ -0,0 +1,34 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def getExt(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+buildscript {
+    ext.kotlin_version = '1.7.21'
+
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+android {
+    compileSdkVersion getExt('compileSdkVersion', 33)
+    buildToolsVersion getExt('buildToolsVersion', '33.0.0')
+
+    defaultConfig {
+        minSdkVersion getExt('minSdkVersion', 21)
+        targetSdkVersion getExt('targetSdkVersion', 33)
+    }
+}
+
+dependencies {
+    compileOnly 'com.facebook.react:react-native:+'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation 'com.amap.api:3dmap:9.6.0'
+}

package/lib/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="qiuxiang.amap3d">
+
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+  <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+</manifest>

package/lib/android/src/main/java/qiuxiang/amap3d/AMap3DPackage.kt

@@ -0,0 +1,28 @@
+package qiuxiang.amap3d
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import qiuxiang.amap3d.map_view.*
+import qiuxiang.amap3d.modules.SdkModule
+
+class AMap3DPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(
+      SdkModule(reactContext),
+    )
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return listOf(
+      MapViewManager(),
+      MarkerManager(),
+      PolylineManager(),
+      PolygonManager(),
+      CircleManager(),
+      HeatMapManager(),
+      MultiPointManager()
+    )
+  }
+}

package/lib/android/src/main/java/qiuxiang/amap3d/Utils.kt

@@ -0,0 +1,114 @@
+package qiuxiang.amap3d
+
+import android.content.res.Resources
+import android.graphics.Bitmap
+import android.graphics.Point
+import android.location.Location
+import android.view.View
+import com.amap.api.maps.model.*
+import com.facebook.drawee.backends.pipeline.Fresco
+import com.facebook.imagepipeline.common.ResizeOptions
+import com.facebook.imagepipeline.request.BasePostprocessor
+import com.facebook.imagepipeline.request.ImageRequestBuilder
+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.views.imagehelper.ImageSource
+
+fun Float.toPx(): Int {
+  return (this * Resources.getSystem().displayMetrics.density).toInt()
+}
+
+fun Int.toPx(): Int {
+  return (this * Resources.getSystem().displayMetrics.density).toInt()
+}
+
+fun ReadableMap.toPoint(): Point {
+  return Point(getDouble("x").toFloat().toPx(), getDouble("y").toFloat().toPx())
+}
+
+fun ReadableMap.toLatLng(): LatLng {
+  return LatLng(getDouble("latitude"), getDouble("longitude"))
+}
+
+fun ReadableArray.toLatLngList(): List<LatLng> {
+  return (0 until size()).map {
+    // @todo 暂时兼容 0.63
+    @Suppress("UNNECESSARY_NOT_NULL_ASSERTION")
+    getMap(it)!!.toLatLng()
+  }
+}
+
+fun LatLng.toJson(): WritableMap {
+  return Arguments.createMap().apply {
+    putDouble("latitude", latitude)
+    putDouble("longitude", longitude)
+  }
+}
+
+fun Poi.toJson(): WritableMap {
+  return Arguments.createMap().apply {
+    putMap("position", coordinate.toJson())
+    putString("id", poiId)
+    putString("name", name)
+  }
+}
+
+fun CameraPosition.toJson(): WritableMap {
+  return Arguments.createMap().apply {
+    putMap("target", target.toJson())
+    putDouble("zoom", zoom.toDouble())
+    putDouble("tilt", tilt.toDouble())
+    putDouble("bearing", bearing.toDouble())
+  }
+}
+
+fun Location.toJson(): WritableMap {
+  return Arguments.createMap().apply {
+    putDouble("timestamp", time.toDouble())
+    putMap("coords", Arguments.createMap().apply {
+      putDouble("latitude", latitude)
+      putDouble("longitude", longitude)
+      putDouble("latitude", latitude)
+      putDouble("accuracy", accuracy.toDouble())
+      putDouble("heading", bearing.toDouble())
+      putDouble("speed", speed.toDouble())
+    })
+  }
+}
+
+fun LatLngBounds.toJson(): WritableMap {
+  return Arguments.createMap().apply {
+    putMap("southwest", southwest.toJson())
+    putMap("northeast", northeast.toJson())
+  }
+}
+
+fun ReadableMap.getFloat(key: String): Float? {
+  if (hasKey(key)) return getDouble(key).toFloat()
+  return null
+}
+
+fun getEventTypeConstants(vararg list: String): Map<String, Any> {
+  return list.associateWith { mapOf("phasedRegistrationNames" to mapOf("bubbled" to it)) }
+}
+
+fun View.fetchImage(source: ReadableMap, callback: (BitmapDescriptor) -> Unit) {
+  val uri = ImageSource(context, source.getString("uri")).uri
+  val request = ImageRequestBuilder.newBuilderWithSource(uri).let {
+    it.postprocessor = object : BasePostprocessor() {
+      override fun process(bitmap: Bitmap) {
+        callback(BitmapDescriptorFactory.fromBitmap(bitmap))
+      }
+    }
+    if (source.hasKey("width") && source.hasKey("height")) {
+      it.resizeOptions = ResizeOptions.forDimensions(
+        source.getInt("width").toPx(),
+        source.getInt("height").toPx()
+      )
+    }
+    it.build()
+  }
+  Fresco.getImagePipeline().fetchDecodedImage(request, this)
+}

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

@@ -0,0 +1,65 @@
+package qiuxiang.amap3d.map_view
+
+import android.content.Context
+import android.graphics.Color
+import com.amap.api.maps.AMap
+import com.amap.api.maps.model.Circle
+import com.amap.api.maps.model.CircleOptions
+import com.amap.api.maps.model.LatLng
+import com.facebook.react.views.view.ReactViewGroup
+
+class Circle(context: Context) : ReactViewGroup(context), Overlay {
+  private var circle: Circle? = null
+
+  var center: LatLng? = null
+    set(value) {
+      field = value
+      circle?.center = value
+    }
+
+  var radius: Double = 0.0
+    set(value) {
+      field = value
+      circle?.radius = value
+    }
+
+  var strokeWidth: Float = 1f
+    set(value) {
+      field = value
+      circle?.strokeWidth = value
+    }
+
+  var strokeColor: Int = Color.BLACK
+    set(value) {
+      field = value
+      circle?.strokeColor = value
+    }
+
+  var fillColor: Int = Color.BLACK
+    set(value) {
+      field = value
+      circle?.fillColor = value
+    }
+
+  var zIndex: Float = 0f
+    set(value) {
+      field = value
+      circle?.zIndex = value
+    }
+
+  override fun add(map: AMap) {
+    circle = map.addCircle(
+      CircleOptions()
+        .center(center)
+        .radius(radius)
+        .strokeColor(strokeColor)
+        .strokeWidth(strokeWidth)
+        .fillColor(fillColor)
+        .zIndex(zIndex)
+    )
+  }
+
+  override fun remove() {
+    circle?.remove()
+  }
+}

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,174 @@
+package qiuxiang.amap3d.map_view
+
+import android.annotation.SuppressLint
+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.CameraPosition
+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.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
+
+  init {
+    super.onCreate(null)
+
+    locationStyle = MyLocationStyle()
+    locationStyle.myLocationType(MyLocationStyle.LOCATION_TYPE_LOCATION_ROTATE_NO_CENTER)
+    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())
+      }
+    }
+  }
+
+  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)
+      }
+    })
+  }
+}

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

@@ -0,0 +1,153 @@
+package qiuxiang.amap3d.map_view
+
+import android.view.View
+import com.amap.api.maps.CameraUpdateFactory
+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 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) },
+  )
+
+  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 = "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()))
+  }
+}