Skip to content

R
react-native-amap3d
Commit 43d80ae7 authored by Qiu Xiang's avatar Qiu Xiang
Browse files
Options

完成到 kotlin 的重构

parent 30e7e8d2
Hide whitespace changes
Inline Side-by-side
Showing with 793 additions and 1014 deletions
android/build.gradle
View file @ 43d80ae7
apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'
buildscript {
ext.kotlin_version = '1.1.2-4'
repositories {
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:2.2.3'
classpath 'com.android.tools.build:gradle:2.3.1'
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
apply plugin: 'com.android.library'
android {
compileSdkVersion 23
buildToolsVersion "23.0.1"
compileSdkVersion 25
buildToolsVersion "25.0.3"
defaultConfig {
minSdkVersion 16
targetSdkVersion 22
versionCode 1
versionName "1.0"
targetSdkVersion 25
}
}
repositories {
jcenter()
}
dependencies {
compile 'com.facebook.react:react-native:+'
compile 'com.amap.api:3dmap:latest.integration'
provided 'com.facebook.react:react-native:+'
compile 'com.amap.api:3dmap:5.1.0'
compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
}
\ No newline at end of file
android/src/main/java/cn/qiuxiang/react/amap3d/AMap3DPackage.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.JavaScriptModule;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class AMap3DPackage implements ReactPackage {
@Override
public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
return Collections.emptyList();
}
@Override
public List<Class<? extends JavaScriptModule>> createJSModules() {
return Collections.emptyList();
}
@Override
public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
return Arrays.<ViewManager>asList(
new AMapViewManager(),
new AMapMarkerManager(),
new AMapOverlayManager(),
new AMapInfoWindowManager(),
new AMapPolylineManager());
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMap3DPackage.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import com.facebook.react.ReactPackage
import com.facebook.react.bridge.JavaScriptModule
import com.facebook.react.bridge.NativeModule
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.uimanager.ViewManager
class AMap3DPackage : ReactPackage {
override fun createJSModules(): List<Class<out JavaScriptModule>> {
return emptyList()
}
override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
return emptyList()
}
override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
return listOf(
AMapViewManager(),
AMapMarkerManager(),
AMapOverlayManager(),
AMapInfoWindowManager(),
AMapPolylineManager())
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapInfoWindow.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.content.Context;
import com.facebook.react.views.view.ReactViewGroup;
public class AMapInfoWindow extends ReactViewGroup {
public AMapInfoWindow(Context context) {
super(context);
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapInfoWindow.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.content.Context
import com.facebook.react.views.view.ReactViewGroup
class AMapInfoWindow(context: Context) : ReactViewGroup(context)
android/src/main/java/cn/qiuxiang/react/amap3d/AMapInfoWindowManager.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.view.ViewGroup;
import com.facebook.react.uimanager.LayoutShadowNode;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.ViewGroupManager;
import java.util.HashMap;
class AMapInfoWindowManager extends ViewGroupManager<AMapInfoWindow> {
@Override
public String getName() {
return "AMapInfoWindow";
}
@Override
protected AMapInfoWindow createViewInstance(ThemedReactContext reactContext) {
return new AMapInfoWindow(reactContext);
}
@Override
public LayoutShadowNode createShadowNodeInstance() {
return new SizeReportingShadowNode();
}
@Override
public void updateExtraData(AMapInfoWindow infoWindow, Object extraData) {
// noinspection unchecked
HashMap<String, Float> data = (HashMap<String, Float>) extraData;
infoWindow.setLayoutParams(new ViewGroup.LayoutParams(
Math.round(data.get("width")), Math.round(data.get("height"))));
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapInfoWindowManager.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.view.ViewGroup.LayoutParams
import com.facebook.react.uimanager.LayoutShadowNode
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.ViewGroupManager
class AMapInfoWindowManager : ViewGroupManager<AMapInfoWindow>() {
override fun getName(): String {
return "AMapInfoWindow"
}
override fun createViewInstance(reactContext: ThemedReactContext): AMapInfoWindow {
return AMapInfoWindow(reactContext)
}
override fun createShadowNodeInstance(): LayoutShadowNode {
return LayoutNode()
}
override fun updateExtraData(infoWindow: AMapInfoWindow, extraData: Any) {
val data = extraData as LayoutNode.Layout
infoWindow.layoutParams = LayoutParams(data.width, data.height)
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapMarker.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.view.View;
import com.amap.api.maps.AMap;
import com.amap.api.maps.model.BitmapDescriptor;
import com.amap.api.maps.model.BitmapDescriptorFactory;
import com.amap.api.maps.model.LatLng;
import com.amap.api.maps.model.Marker;
import com.amap.api.maps.model.MarkerOptions;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.events.RCTEventEmitter;
import com.facebook.react.views.view.ReactViewGroup;
import java.util.HashMap;
import java.util.Map;
@SuppressLint("ViewConstructor")
public class AMapMarker extends ReactViewGroup {
private static final Map<String, Float> COLORS;
static {
COLORS = new HashMap<>();
COLORS.put("HUE_AZURE", BitmapDescriptorFactory.HUE_AZURE);
COLORS.put("HUE_BLUE", BitmapDescriptorFactory.HUE_BLUE);
COLORS.put("HUE_CYAN", BitmapDescriptorFactory.HUE_CYAN);
COLORS.put("HUE_GREEN", BitmapDescriptorFactory.HUE_GREEN);
COLORS.put("HUE_MAGENTA", BitmapDescriptorFactory.HUE_MAGENTA);
COLORS.put("HUE_ORANGE", BitmapDescriptorFactory.HUE_ORANGE);
COLORS.put("HUE_RED", BitmapDescriptorFactory.HUE_RED);
COLORS.put("HUE_ROSE", BitmapDescriptorFactory.HUE_ROSE);
COLORS.put("HUE_VIOLET", BitmapDescriptorFactory.HUE_VIOLET);
COLORS.put("HUE_YELLOW", BitmapDescriptorFactory.HUE_YELLOW);
}
private ReactViewGroup infoWindow;
private Marker marker;
private LatLng position;
private String title = "";
private String snippet = "";
private boolean flat;
private float opacity;
private boolean draggable;
private boolean selected;
private boolean infoWindowEnabled;
private BitmapDescriptor bitmapDescriptor;
private RCTEventEmitter eventEmitter;
public AMapMarker(ThemedReactContext context) {
super(context);
eventEmitter = context.getJSModule(RCTEventEmitter.class);
}
public void addToMap(AMap map) {
marker = map.addMarker(getMarkerOptions());
if (selected) {
marker.showInfoWindow();
} else {
marker.hideInfoWindow();
}
}
public String getMarkerId() {
return marker.getId();
}
private MarkerOptions getMarkerOptions() {
return new MarkerOptions()
.setFlat(flat)
.icon(bitmapDescriptor)
.alpha(opacity)
.draggable(draggable)
.position(position)
.title(title)
.infoWindowEnable(infoWindowEnabled)
.snippet(snippet);
}
public void setTitle(String title) {
this.title = title;
if (marker != null) {
marker.setTitle(title);
}
}
public void setSnippet(String snippet) {
this.snippet = snippet;
if (marker != null) {
marker.setSnippet(snippet);
}
}
public void setCoordinate(ReadableMap coordinate) {
position = new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude"));
if (marker != null) {
marker.setPosition(position);
}
}
public void setFlat(boolean flat) {
this.flat = flat;
if (marker != null) {
marker.setFlat(flat);
}
}
public void setOpacity(float opacity) {
this.opacity = opacity;
if (marker != null) {
marker.setAlpha(opacity);
}
}
public void setDraggable(boolean draggable) {
this.draggable = draggable;
if (marker != null) {
marker.setDraggable(draggable);
}
}
public void setIcon(String icon) {
if (icon.startsWith("HUE_")) {
bitmapDescriptor = BitmapDescriptorFactory.defaultMarker(COLORS.get(icon));
if (marker != null) {
marker.setIcon(bitmapDescriptor);
}
}
}
public void sendEvent(String name, WritableMap data) {
eventEmitter.receiveEvent(getId(), name, data);
}
public void setSelected(boolean selected) {
this.selected = selected;
if (marker != null) {
if (selected) {
marker.showInfoWindow();
} else {
marker.hideInfoWindow();
}
}
}
public ReactViewGroup getInfoWindow() {
return infoWindow;
}
public void setInfoWindow(ReactViewGroup view) {
infoWindow = view;
}
public void setIconView(final AMapOverlay overlay) {
overlay.addOnLayoutChangeListener(new OnLayoutChangeListener() {
@Override
public void onLayoutChange(View view, int i, int i1, int i2, int i3, int i4, int i5, int i6, int i7) {
updateIcon(overlay);
}
});
overlay.setOnUpdateListener(new AMapOverlay.OnUpdateListener() {
@Override
public void onUpdate() {
updateIcon(overlay);
}
});
}
private void updateIcon(AMapOverlay overlay) {
Bitmap bitmap = Bitmap.createBitmap(
overlay.getWidth(),
overlay.getHeight(),
Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
overlay.draw(canvas);
bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(bitmap);
if (marker != null) {
marker.setIcon(bitmapDescriptor);
}
}
public void setEnabledInfoWindow(boolean enabled) {
infoWindowEnabled = enabled;
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapMarker.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.graphics.Bitmap
import android.graphics.Canvas
import com.amap.api.maps.AMap
import com.amap.api.maps.model.*
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.WritableMap
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.events.RCTEventEmitter
import com.facebook.react.views.view.ReactViewGroup
class AMapMarker(context: ThemedReactContext) : ReactViewGroup(context) {
var infoWindow: ReactViewGroup? = null
private var marker: Marker? = null
private var position: LatLng? = null
private var title = ""
private var snippet = ""
private var flat: Boolean = false
private var opacity: Float = 1f
private var draggable: Boolean = false
private var active: Boolean = false
private var infoWindowEnabled: Boolean = true
private var bitmapDescriptor: BitmapDescriptor? = null
private val eventEmitter: RCTEventEmitter = context.getJSModule(RCTEventEmitter::class.java)
fun addToMap(map: AMap) {
marker = map.addMarker(markerOptions)
if (active) {
marker?.showInfoWindow()
} else {
marker?.hideInfoWindow()
}
}
val markerId: String?
get() = marker?.id
private val markerOptions: MarkerOptions
get() = MarkerOptions()
.setFlat(flat)
.icon(bitmapDescriptor)
.alpha(opacity)
.draggable(draggable)
.position(position)
.title(title)
.infoWindowEnable(infoWindowEnabled)
.snippet(snippet)
fun setTitle(title: String) {
this.title = title
marker?.title = title
}
fun setSnippet(snippet: String) {
this.snippet = snippet
marker?.snippet = snippet
}
fun setCoordinate(coordinate: ReadableMap) {
position = LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude"))
marker?.position = position
}
fun setFlat(flat: Boolean) {
this.flat = flat
marker?.isFlat = flat
}
fun setOpacity(opacity: Float) {
this.opacity = opacity
marker?.alpha = opacity
}
fun setDraggable(draggable: Boolean) {
this.draggable = draggable
marker?.isDraggable = draggable
}
fun setIcon(icon: String) {
if (icon.startsWith("HUE_")) {
bitmapDescriptor = COLORS[icon]?.let { BitmapDescriptorFactory.defaultMarker(it) }
marker?.setIcon(bitmapDescriptor)
}
}
fun sendEvent(name: String, data: WritableMap) {
eventEmitter.receiveEvent(id, name, data)
}
fun setActive(selected: Boolean) {
this.active = selected
if (selected) {
marker?.showInfoWindow()
} else {
marker?.hideInfoWindow()
}
}
fun setIconView(overlay: AMapOverlay) {
overlay.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> updateIcon(overlay) }
overlay.setOnUpdateListener(object : AMapOverlay.OnUpdateListener {
override fun onUpdate() {
updateIcon(overlay)
}
})
}
private fun updateIcon(overlay: AMapOverlay) {
val bitmap = Bitmap.createBitmap(
overlay.width, overlay.height, Bitmap.Config.ARGB_8888)
overlay.draw(Canvas(bitmap))
bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(bitmap)
marker?.setIcon(bitmapDescriptor)
}
fun setEnabledInfoWindow(enabled: Boolean) {
infoWindowEnabled = enabled
}
companion object {
private val COLORS = mapOf(
"HUE_AZURE" to BitmapDescriptorFactory.HUE_AZURE,
"HUE_BLUE" to BitmapDescriptorFactory.HUE_BLUE,
"HUE_CYAN" to BitmapDescriptorFactory.HUE_CYAN,
"HUE_GREEN" to BitmapDescriptorFactory.HUE_GREEN,
"HUE_MAGENTA" to BitmapDescriptorFactory.HUE_MAGENTA,
"HUE_ORANGE" to BitmapDescriptorFactory.HUE_ORANGE,
"HUE_RED" to BitmapDescriptorFactory.HUE_RED,
"HUE_ROSE" to BitmapDescriptorFactory.HUE_ROSE,
"HUE_VIOLET" to BitmapDescriptorFactory.HUE_VIOLET,
"HUE_YELLOW" to BitmapDescriptorFactory.HUE_YELLOW
)
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapMarkerManager.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.view.View;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.common.MapBuilder;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.ViewGroupManager;
import com.facebook.react.uimanager.annotations.ReactProp;
import com.facebook.react.views.view.ReactViewGroup;
import java.util.HashMap;
import java.util.Map;
class AMapMarkerManager extends ViewGroupManager<AMapMarker> {
@Override
public String getName() {
return "AMapMarker";
}
@Override
protected AMapMarker createViewInstance(ThemedReactContext reactContext) {
return new AMapMarker(reactContext);
}
@Override
public void addView(AMapMarker marker, View view, int index) {
if (view instanceof AMapInfoWindow) {
marker.setInfoWindow((ReactViewGroup) view);
} else if (view instanceof AMapOverlay) {
marker.setIconView((AMapOverlay) view);
}
}
@Override
public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
HashMap<String, Object> map = new HashMap<>();
map.put("onMarkerClick", MapBuilder.of("registrationName", "onMarkerClick"));
map.put("onMarkerDragStart", MapBuilder.of("registrationName", "onMarkerDragStart"));
map.put("onMarkerDrag", MapBuilder.of("registrationName", "onMarkerDrag"));
map.put("onMarkerDragEnd", MapBuilder.of("registrationName", "onMarkerDragEnd"));
map.put("onInfoWindowClick", MapBuilder.of("registrationName", "onInfoWindowClick"));
return map;
}
@ReactProp(name = "title")
public void setTitle(AMapMarker marker, String title) {
marker.setTitle(title);
}
@ReactProp(name = "description")
public void setSnippet(AMapMarker marker, String description) {
marker.setSnippet(description);
}
@ReactProp(name = "coordinate")
public void setCoordinate(AMapMarker view, ReadableMap coordinate) {
view.setCoordinate(coordinate);
}
@ReactProp(name = "flat")
public void setFlat(AMapMarker marker, boolean flat) {
marker.setFlat(flat);
}
@ReactProp(name = "opacity")
public void setOpacity(AMapMarker marker, float opacity) {
marker.setOpacity(opacity);
}
@ReactProp(name = "draggable")
public void setDraggable(AMapMarker marker, boolean draggable) {
marker.setDraggable(draggable);
}
@ReactProp(name = "selected")
public void setSelected(AMapMarker marker, boolean selected) {
marker.setSelected(selected);
}
@ReactProp(name = "icon")
public void setIcon(AMapMarker marker, String icon) {
marker.setIcon(icon);
}
@ReactProp(name = "showsInfoWindow")
public void setEnabledInfoWindow(AMapMarker marker, boolean enabled) {
marker.setEnabledInfoWindow(enabled);
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapMarkerManager.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.view.View
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.common.MapBuilder
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.ViewGroupManager
import com.facebook.react.uimanager.annotations.ReactProp
import com.facebook.react.views.view.ReactViewGroup
internal class AMapMarkerManager : ViewGroupManager<AMapMarker>() {
override fun getName(): String {
return "AMapMarker"
}
override fun createViewInstance(reactContext: ThemedReactContext): AMapMarker {
return AMapMarker(reactContext)
}
override fun addView(marker: AMapMarker, view: View, index: Int) {
when (view) {
is AMapInfoWindow -> marker.infoWindow = view as ReactViewGroup
is AMapOverlay -> marker.setIconView(view)
}
}
override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
val map = HashMap<String, Any>()
map.put("onMarkerClick", MapBuilder.of("registrationName", "onMarkerClick"))
map.put("onMarkerDragStart", MapBuilder.of("registrationName", "onMarkerDragStart"))
map.put("onMarkerDrag", MapBuilder.of("registrationName", "onMarkerDrag"))
map.put("onMarkerDragEnd", MapBuilder.of("registrationName", "onMarkerDragEnd"))
map.put("onInfoWindowClick", MapBuilder.of("registrationName", "onInfoWindowClick"))
return map
}
@ReactProp(name = "title")
fun setTitle(marker: AMapMarker, title: String) {
marker.setTitle(title)
}
@ReactProp(name = "description")
fun setSnippet(marker: AMapMarker, description: String) {
marker.setSnippet(description)
}
@ReactProp(name = "coordinate")
fun setCoordinate(view: AMapMarker, coordinate: ReadableMap) {
view.setCoordinate(coordinate)
}
@ReactProp(name = "flat")
fun setFlat(marker: AMapMarker, flat: Boolean) {
marker.setFlat(flat)
}
@ReactProp(name = "opacity")
override fun setOpacity(marker: AMapMarker, opacity: Float) {
marker.setOpacity(opacity)
}
@ReactProp(name = "draggable")
fun setDraggable(marker: AMapMarker, draggable: Boolean) {
marker.setDraggable(draggable)
}
@ReactProp(name = "selected")
fun setSelected(marker: AMapMarker, selected: Boolean) {
marker.setActive(selected)
}
@ReactProp(name = "icon")
fun setIcon(marker: AMapMarker, icon: String) {
marker.setIcon(icon)
}
@ReactProp(name = "showsInfoWindow")
fun setEnabledInfoWindow(marker: AMapMarker, enabled: Boolean) {
marker.setEnabledInfoWindow(enabled)
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapOverlay.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.content.Context;
import com.facebook.react.views.view.ReactViewGroup;
public class AMapOverlay extends ReactViewGroup {
private OnUpdateListener onUpdateListener;
public AMapOverlay(Context context) {
super(context);
}
public void setOnUpdateListener(OnUpdateListener listener) {
onUpdateListener = listener;
}
public void update() {
if (onUpdateListener != null) {
onUpdateListener.onUpdate();
}
}
interface OnUpdateListener {
void onUpdate();
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapOverlay.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.content.Context
import com.facebook.react.views.view.ReactViewGroup
class AMapOverlay(context: Context) : ReactViewGroup(context) {
private var onUpdateListener: OnUpdateListener? = null
fun setOnUpdateListener(listener: OnUpdateListener) {
onUpdateListener = listener
}
fun update() {
onUpdateListener?.onUpdate()
}
interface OnUpdateListener {
fun onUpdate()
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapOverlayManager.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.view.ViewGroup;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.common.MapBuilder;
import com.facebook.react.uimanager.LayoutShadowNode;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.ViewGroupManager;
import java.util.HashMap;
import java.util.Map;
class AMapOverlayManager extends ViewGroupManager<AMapOverlay> {
private static final int UPDATE = 1;
@Override
public String getName() {
return "AMapOverlay";
}
@Override
protected AMapOverlay createViewInstance(ThemedReactContext reactContext) {
return new AMapOverlay(reactContext);
}
@Override
public Map<String, Integer> getCommandsMap() {
return MapBuilder.of("update", UPDATE);
}
@Override
public void receiveCommand(AMapOverlay overlay, int commandId, ReadableArray args) {
switch (commandId) {
case UPDATE:
overlay.update();
break;
}
}
@Override
public LayoutShadowNode createShadowNodeInstance() {
return new SizeReportingShadowNode();
}
@Override
public void updateExtraData(AMapOverlay overlay, Object extraData) {
// noinspection unchecked
HashMap<String, Float> data = (HashMap<String, Float>) extraData;
overlay.setLayoutParams(new ViewGroup.LayoutParams(
Math.round(data.get("width")), Math.round(data.get("height"))));
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapOverlayManager.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.view.ViewGroup.LayoutParams
import com.facebook.react.bridge.ReadableArray
import com.facebook.react.uimanager.LayoutShadowNode
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.ViewGroupManager
class AMapOverlayManager : ViewGroupManager<AMapOverlay>() {
override fun getName(): String {
return "AMapOverlay"
}
override fun createViewInstance(reactContext: ThemedReactContext): AMapOverlay {
return AMapOverlay(reactContext)
}
override fun getCommandsMap(): Map<String, Int> {
return mapOf("update" to UPDATE)
}
override fun receiveCommand(overlay: AMapOverlay, commandId: Int, args: ReadableArray?) {
when (commandId) {
UPDATE -> overlay.update()
}
}
override fun createShadowNodeInstance(): LayoutShadowNode {
return LayoutNode()
}
override fun updateExtraData(overlay: AMapOverlay, extraData: Any) {
val data = extraData as LayoutNode.Layout
overlay.layoutParams = LayoutParams(data.width, data.height)
}
companion object {
val UPDATE = 1
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapPolyline.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.annotation.SuppressLint;
import com.amap.api.maps.AMap;
import com.amap.api.maps.model.LatLng;
import com.amap.api.maps.model.Polyline;
import com.amap.api.maps.model.PolylineOptions;
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 com.facebook.react.uimanager.events.RCTEventEmitter;
import com.facebook.react.views.view.ReactViewGroup;
import java.util.ArrayList;
@SuppressLint("ViewConstructor")
public class AMapPolyline extends ReactViewGroup {
private ArrayList<LatLng> coordinates;
private Polyline polyline;
private int color;
private float width;
private float zIndex;
private boolean geodesic;
private boolean dottedLine;
private float opacity;
private ArrayList<Integer> colors;
private boolean gradient;
private RCTEventEmitter eventEmitter;
public AMapPolyline(ThemedReactContext context) {
super(context);
eventEmitter = context.getJSModule(RCTEventEmitter.class);
}
public void setCoordinates(ReadableArray coordinates) {
this.coordinates = new ArrayList<>(coordinates.size());
for (int i = 0; i < coordinates.size(); i++) {
ReadableMap coordinate = coordinates.getMap(i);
this.coordinates.add(i, new LatLng(
coordinate.getDouble("latitude"),
coordinate.getDouble("longitude")));
}
if (polyline != null) {
polyline.setPoints(this.coordinates);
}
}
public void setColor(int color) {
this.color = color;
if (polyline != null) {
polyline.setColor(color);
}
}
public void setWidth(float width) {
this.width = width;
if (polyline != null) {
polyline.setWidth(width);
}
}
public void setZIndex(float zIndex) {
this.zIndex = zIndex;
if (polyline != null) {
polyline.setZIndex(zIndex);
}
}
public void setGeodesic(boolean geodesic) {
this.geodesic = geodesic;
if (polyline != null) {
polyline.setGeodesic(geodesic);
}
}
public void setDottedLine(boolean dottedLine) {
this.dottedLine = dottedLine;
if (polyline != null) {
polyline.setDottedLine(dottedLine);
}
}
public void setGradient(boolean gradient) {
this.gradient = gradient;
}
public void setOpacity(float opacity) {
this.opacity = opacity;
if (polyline != null) {
polyline.setTransparency(opacity);
}
}
public void setColors(ReadableArray colors) {
this.colors = new ArrayList<>(colors.size());
for (int i = 0; i < colors.size(); i++) {
this.colors.add(colors.getInt(i));
}
}
public void addToMap(AMap map) {
polyline = map.addPolyline(new PolylineOptions()
.addAll(coordinates)
.color(color)
.colorValues(colors)
.width(width)
.useGradient(gradient)
.geodesic(geodesic)
.setDottedLine(dottedLine)
.transparency(opacity)
.zIndex(zIndex));
}
public String getPolylineId() {
return polyline.getId();
}
public void sendEvent(String name, WritableMap data) {
eventEmitter.receiveEvent(getId(), name, data);
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapPolyline.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import com.amap.api.maps.AMap
import com.amap.api.maps.model.LatLng
import com.amap.api.maps.model.Polyline
import com.amap.api.maps.model.PolylineOptions
import com.facebook.react.bridge.ReadableArray
import com.facebook.react.bridge.WritableMap
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.events.RCTEventEmitter
import com.facebook.react.views.view.ReactViewGroup
class AMapPolyline(context: ThemedReactContext) : ReactViewGroup(context) {
private var polyline: Polyline? = null
private var coordinates: ArrayList<LatLng> = ArrayList()
private var width: Float = 0f
private var color: Int = 0
private var colors: ArrayList<Int> = ArrayList()
private var opacity: Float = 1f
private var zIndex: Float = 0f
private var geodesic: Boolean = false
private var dottedLine: Boolean = false
private var gradient: Boolean = false
private val eventEmitter: RCTEventEmitter = context.getJSModule(RCTEventEmitter::class.java)
val polylineId: String?
get() = polyline?.id
fun setCoordinates(coordinates: ReadableArray) {
this.coordinates = ArrayList((0..coordinates.size() - 1)
.map { coordinates.getMap(it) }
.map { LatLng(it.getDouble("latitude"), it.getDouble("longitude")) })
polyline?.points = this.coordinates
}
fun setColor(color: Int) {
this.color = color
polyline?.color = color
}
fun setWidth(width: Float) {
this.width = width
polyline?.width = width
}
fun setZIndex(zIndex: Float) {
this.zIndex = zIndex
polyline?.zIndex = zIndex
}
fun setGeodesic(geodesic: Boolean) {
this.geodesic = geodesic
polyline?.isGeodesic = geodesic
}
fun setDottedLine(dottedLine: Boolean) {
this.dottedLine = dottedLine
polyline?.isDottedLine = dottedLine
}
fun setGradient(gradient: Boolean) {
this.gradient = gradient
}
fun setOpacity(opacity: Float) {
this.opacity = opacity
polyline?.setTransparency(opacity)
}
fun setColors(colors: ReadableArray) {
this.colors = ArrayList((0..colors.size() - 1).map { colors.getInt(it) })
}
fun addToMap(map: AMap) {
polyline = map.addPolyline(PolylineOptions()
.addAll(coordinates)
.color(color)
.colorValues(colors)
.width(width)
.useGradient(gradient)
.geodesic(geodesic)
.setDottedLine(dottedLine)
.transparency(opacity)
.zIndex(zIndex))
}
fun sendEvent(name: String, data: WritableMap) {
eventEmitter.receiveEvent(id, name, data)
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapPolylineManager.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.common.MapBuilder;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.ViewGroupManager;
import com.facebook.react.uimanager.annotations.ReactProp;
import java.util.HashMap;
import java.util.Map;
class AMapPolylineManager extends ViewGroupManager<AMapPolyline> {
@Override
public String getName() {
return "AMapPolyline";
}
@Override
protected AMapPolyline createViewInstance(ThemedReactContext reactContext) {
return new AMapPolyline(reactContext);
}
@Override
public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
HashMap<String, Object> map = new HashMap<>();
map.put("onPolylineClick", MapBuilder.of("registrationName", "onPolylineClick"));
return map;
}
@ReactProp(name = "coordinates")
public void setCoordinate(AMapPolyline polyline, ReadableArray coordinates) {
polyline.setCoordinates(coordinates);
}
@ReactProp(name = "colors")
public void setColors(AMapPolyline polyline, ReadableArray colors) {
polyline.setColors(colors);
}
@ReactProp(name = "color", customType = "Color")
public void setColor(AMapPolyline polyline, int color) {
polyline.setColor(color);
}
@ReactProp(name = "width")
public void setWidth(AMapPolyline polyline, int width) {
polyline.setWidth(width);
}
@ReactProp(name = "zIndex")
public void setZIndex(AMapPolyline polyline, int zIndex) {
polyline.setZIndex(zIndex);
}
@ReactProp(name = "opacity")
public void setOpacity(AMapPolyline polyline, float opacity) {
polyline.setOpacity(opacity);
}
@ReactProp(name = "geodesic")
public void setGeodesic(AMapPolyline polyline, boolean geodesic) {
polyline.setGeodesic(geodesic);
}
@ReactProp(name = "dottedLine")
public void setDottedLine(AMapPolyline polyline, boolean dottedLine) {
polyline.setDottedLine(dottedLine);
}
@ReactProp(name = "gradient")
public void setGradient(AMapPolyline polyline, boolean gradient) {
polyline.setGradient(gradient);
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapPolylineManager.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import com.facebook.react.bridge.ReadableArray
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.ViewGroupManager
import com.facebook.react.uimanager.annotations.ReactProp
@Suppress("unused")
internal class AMapPolylineManager : ViewGroupManager<AMapPolyline>() {
override fun getName(): String {
return "AMapPolyline"
}
override fun createViewInstance(reactContext: ThemedReactContext): AMapPolyline {
return AMapPolyline(reactContext)
}
override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
return mapOf("onPolylineClick" to mapOf("registrationName" to "onPolylineClick"))
}
@ReactProp(name = "coordinates")
fun setCoordinate(polyline: AMapPolyline, coordinates: ReadableArray) {
polyline.setCoordinates(coordinates)
}
@ReactProp(name = "colors")
fun setColors(polyline: AMapPolyline, colors: ReadableArray) {
polyline.setColors(colors)
}
@ReactProp(name = "color", customType = "Color")
fun setColor(polyline: AMapPolyline, color: Int) {
polyline.setColor(color)
}
@ReactProp(name = "width")
fun setWidth(polyline: AMapPolyline, width: Int) {
polyline.setWidth(width.toFloat())
}
@ReactProp(name = "zIndex")
fun setZIndex(polyline: AMapPolyline, zIndex: Int) {
polyline.setZIndex(zIndex.toFloat())
}
@ReactProp(name = "opacity")
override fun setOpacity(polyline: AMapPolyline, opacity: Float) {
polyline.setOpacity(opacity)
}
@ReactProp(name = "geodesic")
fun setGeodesic(polyline: AMapPolyline, geodesic: Boolean) {
polyline.setGeodesic(geodesic)
}
@ReactProp(name = "dottedLine")
fun setDottedLine(polyline: AMapPolyline, dottedLine: Boolean) {
polyline.setDottedLine(dottedLine)
}
@ReactProp(name = "gradient")
fun setGradient(polyline: AMapPolyline, gradient: Boolean) {
polyline.setGradient(gradient)
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapView.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Color;
import android.location.Location;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.amap.api.maps.AMap;
import com.amap.api.maps.MapView;
import com.amap.api.maps.UiSettings;
import com.amap.api.maps.model.LatLng;
import com.amap.api.maps.model.Marker;
import com.amap.api.maps.model.MyLocationStyle;
import com.amap.api.maps.model.Polyline;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.events.RCTEventEmitter;
import java.util.HashMap;
import java.util.Map;
@SuppressLint("ViewConstructor")
public class AMapView extends MapView {
public final AMap map;
public final UiSettings ui;
private final RCTEventEmitter eventEmitter;
private Map<String, AMapMarker> markers = new HashMap<>();
private Map<String, AMapPolyline> polylines = new HashMap<>();
public AMapView(final ThemedReactContext context) {
super(context);
super.onCreate(null);
map = this.getMap();
ui = map.getUiSettings();
eventEmitter = context.getJSModule(RCTEventEmitter.class);
// 设置默认的定位模式
MyLocationStyle locationStyle = new MyLocationStyle();
locationStyle.myLocationType(MyLocationStyle.LOCATION_TYPE_LOCATION_ROTATE_NO_CENTER);
map.setMyLocationStyle(locationStyle);
map.setOnMapLoadedListener(new AMap.OnMapLoadedListener() {
@Override
public void onMapLoaded() {
sendEvent("onMapLoaded", Arguments.createMap());
}
});
map.setOnMapClickListener(new AMap.OnMapClickListener() {
@Override
public void onMapClick(LatLng latLng) {
WritableMap event = Arguments.createMap();
event.putDouble("latitude", latLng.latitude);
event.putDouble("longitude", latLng.longitude);
sendEvent("onMapClick", event);
}
});
map.setOnMapLongClickListener(new AMap.OnMapLongClickListener() {
@Override
public void onMapLongClick(LatLng latLng) {
WritableMap event = Arguments.createMap();
event.putDouble("latitude", latLng.latitude);
event.putDouble("longitude", latLng.longitude);
sendEvent("onMapLongClick", event);
}
});
map.setOnMyLocationChangeListener(new AMap.OnMyLocationChangeListener() {
@Override
public void onMyLocationChange(Location location) {
WritableMap event = Arguments.createMap();
event.putDouble("latitude", location.getLatitude());
event.putDouble("longitude", location.getLongitude());
event.putDouble("accuracy", location.getAccuracy());
sendEvent("onLocationChange", event);
}
});
map.setOnMarkerClickListener(new AMap.OnMarkerClickListener() {
@Override
public boolean onMarkerClick(Marker marker) {
markers.get(marker.getId()).sendEvent("onMarkerClick", Arguments.createMap());
return false;
}
});
map.setOnMarkerDragListener(new AMap.OnMarkerDragListener() {
@Override
public void onMarkerDragStart(Marker marker) {
markers.get(marker.getId()).sendEvent("onMarkerDragStart", Arguments.createMap());
}
@Override
public void onMarkerDrag(Marker marker) {
markers.get(marker.getId()).sendEvent("onMarkerDrag", Arguments.createMap());
}
@Override
public void onMarkerDragEnd(Marker marker) {
LatLng position = marker.getPosition();
WritableMap data = Arguments.createMap();
data.putDouble("latitude", position.latitude);
data.putDouble("longitude", position.longitude);
markers.get(marker.getId()).sendEvent("onMarkerDragEnd", data);
}
});
map.setOnInfoWindowClickListener(new AMap.OnInfoWindowClickListener() {
@Override
public void onInfoWindowClick(Marker marker) {
markers.get(marker.getId()).sendEvent("onInfoWindowClick", Arguments.createMap());
}
});
map.setInfoWindowAdapter(new AMap.InfoWindowAdapter() {
@Override
public View getInfoWindow(Marker marker) {
return markers.get(marker.getId()).getInfoWindow();
}
@Override
public View getInfoContents(Marker marker) {
LinearLayout layout = new LinearLayout(context);
layout.setOrientation(LinearLayout.VERTICAL);
TextView titleView = new TextView(context);
titleView.setText(marker.getTitle());
titleView.setTextColor(Color.parseColor("#212121"));
layout.addView(titleView);
String snippet = marker.getSnippet();
if (!snippet.isEmpty()) {
TextView snippetView = new TextView(context);
snippetView.setText(snippet);
snippetView.setSingleLine(false);
snippetView.setMaxEms(12);
snippetView.setPadding(0, (int) pxFromDp(context, 5), 0, 0);
snippetView.setTextColor(Color.parseColor("#757575"));
layout.addView(snippetView);
}
return layout;
}
});
map.setOnPolylineClickListener(new AMap.OnPolylineClickListener() {
@Override
public void onPolylineClick(Polyline polyline) {
polylines.get(polyline.getId()).sendEvent("onPolylineClick", Arguments.createMap());
}
});
}
private static float pxFromDp(Context context, float dp) {
return dp * context.getResources().getDisplayMetrics().density;
}
public void addMarker(AMapMarker marker) {
marker.addToMap(map);
markers.put(marker.getMarkerId(), marker);
}
public void sendEvent(String name, WritableMap data) {
eventEmitter.receiveEvent(getId(), name, data);
}
public void addPolyline(AMapPolyline polyline) {
polyline.addToMap(map);
polylines.put(polyline.getPolylineId(), polyline);
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapView.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.graphics.Color
import android.view.View
import android.widget.LinearLayout
import android.widget.TextView
import com.amap.api.maps.AMap
import com.amap.api.maps.MapView
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.WritableMap
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.events.RCTEventEmitter
class AMapView(context: ThemedReactContext) : MapView(context) {
private val eventEmitter: RCTEventEmitter = context.getJSModule(RCTEventEmitter::class.java)
private val markers = HashMap<String, AMapMarker>()
private val polylines = HashMap<String, AMapPolyline>()
init {
super.onCreate(null)
// 设置默认的定位模式
val locationStyle = MyLocationStyle()
locationStyle.myLocationType(MyLocationStyle.LOCATION_TYPE_LOCATION_ROTATE_NO_CENTER)
map.myLocationStyle = locationStyle
map.setOnMapLoadedListener {
sendEvent("onMapLoaded", Arguments.createMap())
}
map.setOnMapClickListener { latLng ->
val event = Arguments.createMap()
event.putDouble("latitude", latLng.latitude)
event.putDouble("longitude", latLng.longitude)
sendEvent("onMapClick", event)
}
map.setOnMapLongClickListener { latLng ->
val event = Arguments.createMap()
event.putDouble("latitude", latLng.latitude)
event.putDouble("longitude", latLng.longitude)
sendEvent("onMapLongClick", event)
}
map.setOnMyLocationChangeListener { location ->
val event = Arguments.createMap()
event.putDouble("latitude", location.latitude)
event.putDouble("longitude", location.longitude)
event.putDouble("accuracy", location.accuracy.toDouble())
sendEvent("onLocationChange", event)
}
map.setOnMarkerClickListener { marker ->
markers[marker.id]?.sendEvent("onMarkerClick", Arguments.createMap())
false
}
map.setOnMarkerDragListener(object : AMap.OnMarkerDragListener {
override fun onMarkerDragStart(marker: Marker) {
markers[marker.id]?.sendEvent("onMarkerDragStart", Arguments.createMap())
}
override fun onMarkerDrag(marker: Marker) {
markers[marker.id]?.sendEvent("onMarkerDrag", Arguments.createMap())
}
override fun onMarkerDragEnd(marker: Marker) {
val position = marker.position
val data = Arguments.createMap()
data.putDouble("latitude", position.latitude)
data.putDouble("longitude", position.longitude)
markers[marker.id]?.sendEvent("onMarkerDragEnd", data)
}
})
map.setOnInfoWindowClickListener { marker ->
markers[marker.id]?.sendEvent("onInfoWindowClick", Arguments.createMap())
}
map.setInfoWindowAdapter(object : AMap.InfoWindowAdapter {
private val paddingTop = context.resources.displayMetrics.density
override fun getInfoWindow(marker: Marker): View {
return markers[marker.id]?.infoWindow as View
}
override fun getInfoContents(marker: Marker): View {
val layout = LinearLayout(context)
layout.orientation = LinearLayout.VERTICAL
val titleView = TextView(context)
titleView.text = marker.title
titleView.setTextColor(Color.parseColor("#212121"))
layout.addView(titleView)
val snippet = marker.snippet
if (!snippet.isEmpty()) {
val snippetView = TextView(context)
snippetView.text = snippet
snippetView.setSingleLine(false)
snippetView.maxEms = 12
snippetView.setPadding(0, paddingTop.toInt(), 0, 0)
snippetView.setTextColor(Color.parseColor("#757575"))
layout.addView(snippetView)
}
return layout
}
})
map.setOnPolylineClickListener { polyline ->
polylines[polyline.id]?.sendEvent("onPolylineClick", Arguments.createMap())
}
}
fun addMarker(marker: AMapMarker) {
marker.addToMap(map)
markers.put(marker.markerId!!, marker)
}
fun addPolyline(polyline: AMapPolyline) {
polyline.addToMap(map)
polylines.put(polyline.polylineId!!, polyline)
}
fun sendEvent(name: String, data: WritableMap) {
eventEmitter.receiveEvent(id, name, data)
}
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapViewManager.java deleted 100644 → 0
View file @ 30e7e8d2
package cn.qiuxiang.react.amap3d;
import android.view.View;
import com.amap.api.maps.AMap;
import com.amap.api.maps.CameraUpdateFactory;
import com.amap.api.maps.model.LatLng;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.common.MapBuilder;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.ViewGroupManager;
import com.facebook.react.uimanager.annotations.ReactProp;
import java.util.HashMap;
import java.util.Map;
class AMapViewManager extends ViewGroupManager<AMapView> {
private final Map<String, Integer> MAP_TYPES = MapBuilder.of(
"standard", AMap.MAP_TYPE_NORMAL,
"satellite", AMap.MAP_TYPE_SATELLITE,
"navigation", AMap.MAP_TYPE_NAVI,
"night", AMap.MAP_TYPE_NIGHT
);
@Override
public String getName() {
return "AMapView";
}
@Override
public void addView(AMapView mapView, View child, int index) {
if (child instanceof AMapMarker) {
mapView.addMarker((AMapMarker) child);
} else if (child instanceof AMapPolyline) {
mapView.addPolyline((AMapPolyline) child);
}
}
@Override
protected AMapView createViewInstance(ThemedReactContext reactContext) {
return new AMapView(reactContext);
}
@Override
public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
HashMap<String, Object> map = new HashMap<>();
map.put("onMapLoaded", MapBuilder.of("registrationName", "onReady"));
map.put("onMapClick", MapBuilder.of("registrationName", "onPress"));
map.put("onMapLongClick", MapBuilder.of("registrationName", "onLongPress"));
map.put("onLocationChange", MapBuilder.of("registrationName", "onLocation"));
return map;
}
@ReactProp(name = "locationEnabled")
public void setMyLocationEnabled(AMapView view, boolean enabled) {
view.map.setMyLocationEnabled(enabled);
}
@ReactProp(name = "showsIndoorMap")
public void showIndoorMap(AMapView view, boolean show) {
view.map.showIndoorMap(show);
}
@ReactProp(name = "showsIndoorSwitch")
public void setIndoorSwitchEnabled(AMapView view, boolean show) {
view.ui.setIndoorSwitchEnabled(show);
}
@ReactProp(name = "showsBuildings")
public void showBuildings(AMapView view, boolean show) {
view.map.showBuildings(show);
}
@ReactProp(name = "showsLabels")
public void showMapText(AMapView view, boolean show) {
view.map.showMapText(show);
}
@ReactProp(name = "showsCompass")
public void setCompassEnabled(AMapView view, boolean show) {
view.ui.setCompassEnabled(show);
}
@ReactProp(name = "showsZoomControls")
public void setZoomControlsEnabled(AMapView view, boolean enabled) {
view.ui.setZoomControlsEnabled(enabled);
}
@ReactProp(name = "showsScale")
public void setScaleControlsEnabled(AMapView view, boolean enabled) {
view.ui.setScaleControlsEnabled(enabled);
}
@ReactProp(name = "showsLocationButton")
public void setMyLocationButtonEnabled(AMapView view, boolean enabled) {
view.ui.setMyLocationButtonEnabled(enabled);
}
@ReactProp(name = "showsTraffic")
public void setTrafficEnabled(AMapView view, boolean enabled) {
view.map.setTrafficEnabled(enabled);
}
@ReactProp(name = "maxZoomLevel")
public void setMaxZoomLevel(AMapView view, float zoomLevel) {
view.map.setMaxZoomLevel(zoomLevel);
}
@ReactProp(name = "minZoomLevel")
public void setMinZoomLevel(AMapView view, float zoomLevel) {
view.map.setMinZoomLevel(zoomLevel);
}
@ReactProp(name = "zoomLevel")
public void setZoomLevel(AMapView view, float zoomLevel) {
view.map.moveCamera(CameraUpdateFactory.zoomTo(zoomLevel));
}
@ReactProp(name = "mapType")
public void setMapType(AMapView view, String mapType) {
view.map.setMapType(MAP_TYPES.get(mapType));
}
@ReactProp(name = "zoomEnabled")
public void setZoomGesturesEnabled(AMapView view, boolean enabled) {
view.ui.setZoomGesturesEnabled(enabled);
}
@ReactProp(name = "scrollEnabled")
public void setScrollGesturesEnabled(AMapView view, boolean enabled) {
view.ui.setScrollGesturesEnabled(enabled);
}
@ReactProp(name = "rotateEnabled")
public void setRotateGesturesEnabled(AMapView view, boolean enabled) {
view.ui.setRotateGesturesEnabled(enabled);
}
@ReactProp(name = "tiltEnabled")
public void setTiltGesturesEnabled(AMapView view, boolean enabled) {
view.ui.setTiltGesturesEnabled(enabled);
}
@ReactProp(name = "coordinate")
public void moveToCoordinate(AMapView view, ReadableMap coordinate) {
view.map.moveCamera(CameraUpdateFactory.changeLatLng(new LatLng(
coordinate.getDouble("latitude"),
coordinate.getDouble("longitude"))));
}
@ReactProp(name = "tilt")
public void changeTilt(AMapView view, float tilt) {
view.map.moveCamera(CameraUpdateFactory.changeTilt(tilt));
}
// todo: 自定义 locationStyle
}
android/src/main/java/cn/qiuxiang/react/amap3d/AMapViewManager.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import android.view.View
import com.amap.api.maps.AMap
import com.amap.api.maps.CameraUpdateFactory
import com.amap.api.maps.model.LatLng
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
internal class AMapViewManager : ViewGroupManager<AMapView>() {
override fun getName(): String {
return "AMapView"
}
override fun addView(mapView: AMapView, child: View, index: Int) {
when (child) {
is AMapMarker -> mapView.addMarker(child)
is AMapPolyline -> mapView.addPolyline(child)
}
}
override fun createViewInstance(reactContext: ThemedReactContext): AMapView {
return AMapView(reactContext)
}
override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
return mapOf(
"onMapLoaded" to mapOf("registrationName" to "onReady"),
"onMapClick" to mapOf("registrationName" to "onPress"),
"onMapLongClick" to mapOf("registrationName" to "onLongPress"),
"onLocationChange" to mapOf("registrationName" to "onLocation"))
}
@ReactProp(name = "locationEnabled")
fun setMyLocationEnabled(view: AMapView, enabled: Boolean) {
view.map.isMyLocationEnabled = enabled
}
@ReactProp(name = "showsIndoorMap")
fun showIndoorMap(view: AMapView, show: Boolean) {
view.map.showIndoorMap(show)
}
@ReactProp(name = "showsIndoorSwitch")
fun setIndoorSwitchEnabled(view: AMapView, show: Boolean) {
view.map.uiSettings.isIndoorSwitchEnabled = show
}
@ReactProp(name = "showsBuildings")
fun showBuildings(view: AMapView, show: Boolean) {
view.map.showBuildings(show)
}
@ReactProp(name = "showsLabels")
fun showMapText(view: AMapView, show: Boolean) {
view.map.showMapText(show)
}
@ReactProp(name = "showsCompass")
fun setCompassEnabled(view: AMapView, show: Boolean) {
view.map.uiSettings.isCompassEnabled = show
}
@ReactProp(name = "showsZoomControls")
fun setZoomControlsEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isZoomControlsEnabled = enabled
}
@ReactProp(name = "showsScale")
fun setScaleControlsEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isScaleControlsEnabled = enabled
}
@ReactProp(name = "showsLocationButton")
fun setMyLocationButtonEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isMyLocationButtonEnabled = enabled
}
@ReactProp(name = "showsTraffic")
fun setTrafficEnabled(view: AMapView, enabled: Boolean) {
view.map.isTrafficEnabled = enabled
}
@ReactProp(name = "maxZoomLevel")
fun setMaxZoomLevel(view: AMapView, zoomLevel: Float) {
view.map.maxZoomLevel = zoomLevel
}
@ReactProp(name = "minZoomLevel")
fun setMinZoomLevel(view: AMapView, zoomLevel: Float) {
view.map.minZoomLevel = zoomLevel
}
@ReactProp(name = "zoomLevel")
fun setZoomLevel(view: AMapView, zoomLevel: Float) {
view.map.moveCamera(CameraUpdateFactory.zoomTo(zoomLevel))
}
@ReactProp(name = "mapType")
fun setMapType(view: AMapView, mapType: String) {
when (mapType) {
"standard" -> view.map.mapType = AMap.MAP_TYPE_NORMAL
"satellite" -> view.map.mapType = AMap.MAP_TYPE_SATELLITE
"navigation" -> view.map.mapType = AMap.MAP_TYPE_NAVI
"night" -> view.map.mapType = AMap.MAP_TYPE_NIGHT
}
}
@ReactProp(name = "zoomEnabled")
fun setZoomGesturesEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isZoomGesturesEnabled = enabled
}
@ReactProp(name = "scrollEnabled")
fun setScrollGesturesEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isScrollGesturesEnabled = enabled
}
@ReactProp(name = "rotateEnabled")
fun setRotateGesturesEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isRotateGesturesEnabled = enabled
}
@ReactProp(name = "tiltEnabled")
fun setTiltGesturesEnabled(view: AMapView, enabled: Boolean) {
view.map.uiSettings.isTiltGesturesEnabled = enabled
}
@ReactProp(name = "coordinate")
fun moveToCoordinate(view: AMapView, coordinate: ReadableMap) {
view.map.moveCamera(CameraUpdateFactory.changeLatLng(LatLng(
coordinate.getDouble("latitude"),
coordinate.getDouble("longitude"))))
}
@ReactProp(name = "tilt")
fun changeTilt(view: AMapView, tilt: Float) {
view.map.moveCamera(CameraUpdateFactory.changeTilt(tilt))
}
// todo: 自定义 locationStyle
}
android/src/main/java/cn/qiuxiang/react/amap3d/LayoutNode.kt 0 → 100644
View file @ 43d80ae7
package cn.qiuxiang.react.amap3d
import com.facebook.react.uimanager.LayoutShadowNode
import com.facebook.react.uimanager.UIViewOperationQueue
class LayoutNode : LayoutShadowNode() {
override fun onCollectExtraUpdates(operationQueue: UIViewOperationQueue) {
super.onCollectExtraUpdates(operationQueue)
operationQueue.enqueueUpdateExtraData(reactTag, Layout(
layoutWidth.toInt(),
layoutHeight.toInt()))
}
class Layout(var width: Int, var height: Int)
}
android/src/main/java/cn/qiuxiang/react/amap3d/SizeReportingShadowNode.java deleted 100644 → 0
View file @ 30e7e8d2
/*
Copyright (c) 2015-present, Facebook, Inc.
All rights reserved.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree. An additional grant
of patent rights can be found in the PATENTS file in the same directory.
*/
package cn.qiuxiang.react.amap3d;
import com.facebook.react.uimanager.LayoutShadowNode;
import com.facebook.react.uimanager.UIViewOperationQueue;
import java.util.HashMap;
import java.util.Map;
// Custom LayoutShadowNode implementation used in conjunction with the AirMapManager
// which sends the width/height of the view after layout occurs.
class SizeReportingShadowNode extends LayoutShadowNode {
@Override
public void onCollectExtraUpdates(UIViewOperationQueue uiViewOperationQueue) {
super.onCollectExtraUpdates(uiViewOperationQueue);
Map<String, Float> data = new HashMap<>();
data.put("width", getLayoutWidth());
data.put("height", getLayoutHeight());
uiViewOperationQueue.enqueueUpdateExtraData(getReactTag(), data);
}
}
example/android/gradle/wrapper/gradle-wrapper.properties
View file @ 43d80ae7
......@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-3.5-all.zip
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment