react-native-map4d-map-dtqg 0.1.0

package/android/src/main/java/com/reactnativemap4dmap/RMFBuilding.java

@@ -0,0 +1,167 @@
+package com.reactnativemap4dmap;
+
+import android.content.Context;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import vn.map4d.map.annotations.MFBuilding;
+import vn.map4d.map.annotations.MFBuildingOptions;
+import vn.map4d.map.core.Map4D;
+import vn.map4d.types.MFLocationCoordinate;
+
+public class RMFBuilding extends RMFFeature {
+
+  private MFBuilding building;
+
+  private String name;
+
+  private MFLocationCoordinate coordinate;
+
+  private String model;
+
+  private String texture;
+
+  private double scale;
+
+  private double bearing;
+
+  private float elevation;
+
+  private boolean selected;
+
+  private boolean visible;
+
+  private boolean touchable;
+
+  private String userData;
+
+  public RMFBuilding(Context context) {
+    super(context);
+    name = "";
+    model = "";
+    texture = "";
+    coordinate = new MFLocationCoordinate(0, 0);
+    scale = 1.0;
+    bearing = 0.0;
+    elevation = 0.f;
+    selected = false;
+    visible = true;
+    touchable = true;
+    userData = null;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+    if (building != null) {
+      building.setName(this.name);
+    }
+  }
+
+  public void setCoordinate(ReadableMap data) {
+    this.coordinate = new MFLocationCoordinate(data.getDouble("latitude"), data.getDouble("longitude"));
+    if (building != null) {
+      building.setLocation(this.coordinate);
+    }
+  }
+
+  public void setModelUrl(String url) {
+    this.model = url;
+    if (building != null) {
+      building.setModel(this.model);
+    }
+  }
+
+  public void setTextureUrl(String url) {
+    this.texture = url;
+    if (building != null) {
+      building.setTexture(this.texture);
+    }
+  }
+
+  public void setScale(double scale) {
+    this.scale = scale;
+    if (building != null) {
+      building.setScale(this.scale);
+    }
+  }
+
+  public void setBearing(double bearing) {
+    this.bearing = bearing;
+    if (building != null) {
+      building.setBearing(this.bearing);
+    }
+  }
+
+  public void setElevation(float elevation) {
+    this.elevation = elevation;
+    if (building != null) {
+      building.setElevation(this.elevation);
+    }
+  }
+
+  public void setSelected(boolean selected) {
+    this.selected = selected;
+    if (building != null) {
+      building.setSelected(this.selected);
+    }
+  }
+
+  public void setVisible(boolean visible) {
+    this.visible = visible;
+    if (building != null) {
+      building.setVisible(this.visible);
+    }
+  }
+
+  public void setTouchable(boolean touchable) {
+    this.touchable = touchable;
+    if (building != null) {
+      building.setTouchable(this.touchable);
+    }
+  }
+
+  public void setUserData(ReadableMap userData) {
+    this.userData = userData.toString();
+    if (building != null) {
+      building.setUserData(this.userData);
+    }
+  }
+
+  @Override
+  public void addToMap(Map4D map) {
+    this.building = map.addBuilding(getOptions());
+  }
+
+  @Override
+  public void removeFromMap(Map4D map) {
+    if (building == null) {
+      return;
+    }
+    building.remove();
+    building = null;
+  }
+
+  @Override
+  public Object getFeature() {
+    return building;
+  }
+
+  public MFBuildingOptions getOptions() {
+    MFBuildingOptions options = new MFBuildingOptions();
+    options.name(name);
+    options.location(coordinate);
+    options.model(model);
+    options.texture(texture);
+    options.scale(scale);
+    options.bearing(bearing);
+    options.elevation(elevation);
+    options.visible(visible);
+    options.touchable(touchable);
+    options.userData(userData);
+    return options;
+  }
+}

package/android/src/main/java/com/reactnativemap4dmap/RMFBuildingManager.java

@@ -0,0 +1,121 @@
+package com.reactnativemap4dmap;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+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.Map;
+
+public class RMFBuildingManager extends ViewGroupManager<RMFBuilding> {
+
+  @NonNull
+  @Override
+  public String getName() {
+    return "RMFBuilding";
+  }
+
+  @NonNull
+  @Override
+  protected RMFBuilding createViewInstance(@NonNull ThemedReactContext reactContext) {
+    return new RMFBuilding(reactContext);
+  }
+
+  @Override
+  public void receiveCommand(@NonNull RMFBuilding view, String commandId, @Nullable ReadableArray args) {
+    ReadableMap data;
+    switch (commandId) {
+      case "setName":
+        view.setName(args.getString(0));
+        break;
+      case "setScale":
+        view.setScale(args.getDouble(0));
+        break;
+      case "setBearing":
+        view.setBearing(args.getDouble(0));
+        break;
+      case "setElevation":
+        view.setElevation((float) args.getDouble(0));
+        break;
+      case "setSelected":
+        view.setSelected(args.getBoolean(0));
+        break;
+      case "setVisible":
+        view.setVisible(args.getBoolean(0));
+        break;
+      case "setTouchable":
+        view.setTouchable(args.getBoolean(0));
+        break;
+      case "setUserData":
+        data = args.getMap(0);
+        view.setUserData(data);
+        break;
+    }
+  }
+
+  @Override
+  public Map getExportedCustomDirectEventTypeConstants() {
+    final Map<String, Map<String, String>> map = MapBuilder.of("onPress", MapBuilder.of("registrationName", "onPress"));
+    return map;
+  }
+
+  @ReactProp(name = "name")
+  public void setName(final RMFBuilding view, final String name) {
+    view.setName(name);
+  }
+
+  @ReactProp(name = "coordinate")
+  public void setCoordinate(final RMFBuilding view, final ReadableMap map) {
+    view.setCoordinate(map);
+  }
+
+  @ReactProp(name = "modelUrl")
+  public void setModelUrl(final RMFBuilding view, final String url) {
+    view.setModelUrl(url);
+  }
+
+  @ReactProp(name = "textureUrl")
+  public void setTextureUrl(final RMFBuilding view, final String url) {
+    view.setTextureUrl(url);
+  }
+
+  @ReactProp(name = "scale")
+  public void setScale(final RMFBuilding view, final double scale) {
+    view.setScale(scale);
+  }
+
+  @ReactProp(name = "bearing")
+  public void setBearing(final RMFBuilding view, final double bearing) {
+    view.setBearing(bearing);
+  }
+
+  @ReactProp(name = "elevation")
+  public void setElevation(final RMFBuilding view, final float elevation) {
+    view.setElevation(elevation);
+  }
+
+  @ReactProp(name = "selected")
+  public void setSelected(final RMFBuilding view, final boolean selected) {
+    view.setSelected(selected);
+  }
+
+  @ReactProp(name = "visible")
+  public void setVisible(final RMFBuilding view, final boolean visible) {
+    view.setVisible(visible);
+  }
+
+  @ReactProp(name = "touchable")
+  public void setTouchable(final RMFBuilding view, final boolean touchable) {
+    view.setTouchable(touchable);
+  }
+
+  @ReactProp(name = "userData")
+  public void setUserData(final RMFBuilding view, final ReadableMap userData) {
+    view.setUserData(userData);
+  }
+}

package/android/src/main/java/com/reactnativemap4dmap/RMFCircle.java

@@ -0,0 +1,105 @@
+package com.reactnativemap4dmap;
+
+import android.content.Context;
+
+import androidx.annotation.ColorInt;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import vn.map4d.map.core.*;
+import vn.map4d.map.annotations.*;
+
+import vn.map4d.types.MFLocationCoordinate;
+
+public class RMFCircle extends RMFFeature {
+  private MFCircle circle;
+  private MFLocationCoordinate position;
+  private Double radius;
+  private @ColorInt int fillColor;
+  private @ColorInt int strokeColor;
+  private double strokeWidth;
+  private double zIndex;
+  private Boolean visible = true;
+
+  public RMFCircle(Context context) {
+    super(context);
+  }
+
+  public void setCenter(ReadableMap data) {
+    this.position = new MFLocationCoordinate(data.getDouble("latitude"), data.getDouble("longitude"));
+    if (circle != null) {
+      circle.setCenter(this.position);
+    }
+  }
+
+  public void setRadius(double data) {
+    radius = data;
+    if (circle != null) {
+      circle.setRadius(radius);
+    }
+  }
+
+  public void setZIndex(double data) {
+    zIndex = data;
+    if (circle != null) {
+      circle.setZIndex((float) zIndex);
+    }
+  }
+
+  public void setVisible(Boolean data) {
+    visible = data;
+    if (circle != null) {
+      circle.setVisible(data);
+    }
+  }
+
+  public void setStrokeColor(@ColorInt int strokeColor) {
+    this.strokeColor = strokeColor;
+    if (circle != null) {
+      circle.setStrokeColor(this.strokeColor);
+    }
+  }
+
+  public void setFillColor(@ColorInt int fillColor) {
+    this.fillColor = fillColor;
+    if (circle != null) {
+      circle.setFillColor(this.fillColor);
+    }
+  }
+
+  public void setStrokeWidth(double width) {
+    this.strokeWidth = width;
+    if (circle != null) {
+      circle.setStrokeWidth((float) this.strokeWidth);
+    }
+  }
+
+  public void addToMap(Map4D map) {
+    this.circle = map.addCircle(getOptions());
+  }
+
+  public void removeFromMap(Map4D map) {
+    if (circle == null) {
+      return;
+    }
+    circle.remove();
+    circle = null;
+    //updateTracksViewChanges();
+  }
+
+  public MFCircleOptions getOptions() {
+    MFCircleOptions options = new MFCircleOptions()
+      .center(this.position)
+      .radius(radius)
+      .fillColor(fillColor)
+      .strokeColor(strokeColor)
+      .strokeWidth((float) strokeWidth)
+      .zIndex((float) zIndex)
+      .visible(visible);
+    return options;
+  }
+
+  public Object getFeature() {
+    return circle;
+  }
+}

package/android/src/main/java/com/reactnativemap4dmap/RMFCircleManager.java

@@ -0,0 +1,122 @@
+package com.reactnativemap4dmap;
+
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.bridge.*;
+import com.facebook.react.uimanager.annotations.*;
+import com.facebook.react.common.MapBuilder;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.ColorInt;
+
+import java.util.Map;
+import java.util.HashMap;
+
+
+public class RMFCircleManager extends ViewGroupManager<RMFCircle> {
+    private static final int k_setCenter = 1;
+    private static final int k_setRadius = 2;
+    private static final int k_setFillColor = 3;
+    private static final int k_setStrokeColor = 4;
+    private static final int k_setZIndex = 5;
+    private static final int k_setStrokeWidth = 6;
+    private static final int k_setVisible = 7;
+
+    @Override
+    public String getName() {
+        return "RMFCircle";
+    }
+
+    @Override
+    protected RMFCircle createViewInstance(ThemedReactContext reactContext) {        
+        return new RMFCircle(reactContext);
+    }
+
+    @Override
+    public void receiveCommand(RMFCircle view, int commandId, @Nullable ReadableArray args) {    
+      ReadableMap data;
+      switch (commandId) {
+        case k_setCenter:
+        data = args.getMap(0);
+          view.setCenter(data);
+          break;
+        case k_setRadius:        
+          view.setRadius(args.getDouble(0));
+          break;
+        case k_setFillColor:
+          view.setFillColor(args.getInt(0));
+          break;
+        case k_setStrokeColor:
+          view.setStrokeColor(args.getInt(0));
+          break;
+        case k_setStrokeWidth:
+          view.setStrokeWidth(args.getDouble(0));
+          break;
+        case k_setZIndex:
+          view.setZIndex(args.getDouble(0));
+          break;
+        case k_setVisible:
+          view.setVisible(args.getBoolean(0));
+          break;
+      }
+    }
+
+    @Override
+    public Map getExportedCustomDirectEventTypeConstants() {
+      Map<String, Map<String, String>> map = MapBuilder.of(
+        "onPress", MapBuilder.of("registrationName", "onPress")
+      );
+      return map;
+    }
+
+
+    @Nullable
+  @Override
+  public Map<String, Integer> getCommandsMap() {
+    HashMap<String, Integer> map = new HashMap();    
+    map.put("setCenter", k_setCenter);
+    map.put("setRadius", k_setRadius);
+    map.put("setFillColor", k_setFillColor);
+    map.put("setStrokeColor", k_setStrokeColor);
+    map.put("setZIndex", k_setZIndex);  
+    map.put("setStrokeWidth", k_setStrokeWidth); 
+    map.put("setVisible", k_setVisible); 
+    return map;
+  }
+
+  @ReactProp(name = "visible")
+  public void setVisible(RMFCircle view, Boolean data) {
+    view.setVisible(data);
+  }
+
+   @ReactProp(name = "center")
+   public void setCenter(RMFCircle view, ReadableMap map) {
+        view.setCenter(map);
+   }
+
+   @ReactProp(name = "strokeWidth")
+   public void setStrokeWidth(RMFCircle view, double data) {
+        view.setStrokeWidth(data);
+   }
+
+   @ReactProp(name = "zIndex")
+   public void setZIndex(RMFCircle view, double data) {
+        view.setZIndex(data);
+   }
+
+   @ReactProp(name = "radius")
+   public void setRadius(RMFCircle view, double data) {
+        view.setRadius(data);
+   }
+
+   @ReactProp(name = "fillColor", customType = "Color")
+   public void setFillColor(RMFCircle view, @ColorInt int data) {
+        view.setFillColor(data);
+   }
+
+   @ReactProp(name = "strokeColor", customType = "Color")
+   public void setStrokeColor(RMFCircle view, @ColorInt int data) {
+        view.setStrokeColor(data);
+   }   
+
+}