react-native-map4d-map-dtqg 0.1.0

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

@@ -0,0 +1,212 @@
+package com.reactnativemap4dmap;
+
+import android.content.Context;
+import android.os.Build;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+import android.view.View;
+
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.bridge.*;
+import com.facebook.react.uimanager.annotations.*;
+import com.facebook.react.common.MapBuilder;
+
+import androidx.annotation.Nullable;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class RMFMarkerManager extends ViewGroupManager<RMFMarker> {
+  private final DisplayMetrics metrics;
+
+  private static final int k_setCoordinate = 1;
+  private static final int k_setRotation = k_setCoordinate + 1;
+  private static final int k_setTitle = k_setRotation + 1;
+  private static final int k_setSnippet = k_setTitle + 1;
+  private static final int k_setDraggable = k_setSnippet + 1;
+  private static final int k_setZIndex = k_setDraggable + 1;
+  private static final int k_setVisible = k_setZIndex + 1;
+  private static final int k_setInfoWindowAnchor = k_setVisible + 1;
+  private static final int k_setElevation = k_setInfoWindowAnchor + 1;
+  private static final int k_setUserData = k_setElevation + 1;
+
+  public RMFMarkerManager(ReactApplicationContext reactContext) {
+    super();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+      metrics = new DisplayMetrics();
+      ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
+          .getDefaultDisplay()
+          .getRealMetrics(metrics);
+    } else {
+      metrics = reactContext.getResources().getDisplayMetrics();
+    }
+  }
+
+  @Override
+  public String getName() {
+    return "RMFMarker";
+  }
+
+  @Override
+  protected RMFMarker createViewInstance(ThemedReactContext reactContext) {
+    return new RMFMarker(reactContext);
+  }
+
+  @Override
+  public void receiveCommand(RMFMarker view, int commandId, @Nullable ReadableArray args) {
+    ReadableMap data;
+    switch (commandId) {
+      case k_setCoordinate:
+        data = args.getMap(0);
+        view.setPosition(data);
+        break;
+      case k_setRotation:
+        view.setRotation(args.getDouble(0));
+        break;
+      case k_setTitle:
+        view.setTitle(args.getString(0));
+        break;
+      case k_setSnippet:
+        view.setSnippet(args.getString(0));
+        break;
+      case k_setDraggable:
+        view.setDraggable(args.getBoolean(0));
+        break;
+      case k_setZIndex:
+        view.setZIndex(args.getDouble(0));
+        break;
+      case k_setVisible:
+        view.setVisible(args.getBoolean(0));
+        break;
+      case k_setInfoWindowAnchor:
+        data = args.getMap(0);
+        view.setInfoWindowAnchor(data);
+        break;
+      case k_setElevation:
+        view.setElevation(args.getDouble(0));
+        break;
+      case k_setUserData:
+        data = args.getMap(0);
+        view.setUserData(data);
+        break;
+    }
+  }
+
+  @Override
+  public Map getExportedCustomDirectEventTypeConstants() {
+    Map<String, Map<String, String>> map = MapBuilder.of(
+      "onDrag", MapBuilder.of("registrationName", "onDrag"),
+      "onDragStart", MapBuilder.of("registrationName", "onDragStart"),
+      "onDragEnd", MapBuilder.of("registrationName", "onDragEnd"),
+      "onPress", MapBuilder.of("registrationName", "onPress"),
+      "onPressInfoWindow", MapBuilder.of("registrationName", "onPressInfoWindow")
+    );
+    return map;
+  }
+
+  @Nullable
+  @Override
+  public Map<String, Integer> getCommandsMap() {
+    HashMap<String, Integer> map = new HashMap();
+    map.put("setCoordinate", k_setCoordinate);
+    map.put("setRotation", k_setRotation);
+    map.put("setTitle", k_setTitle);
+    map.put("setSnippet", k_setSnippet);
+    map.put("setDraggable", k_setDraggable);
+    map.put("setZIndex", k_setZIndex);
+    map.put("setVisible", k_setVisible);
+    map.put("setInfoWindowAnchor", k_setInfoWindowAnchor);
+    map.put("setElevation", k_setElevation);
+    map.put("setUserData", k_setUserData);
+    return map;
+  }
+
+  @Override
+  public void addView(RMFMarker parent, View child, int index) {
+    super.addView(parent, child, index);
+  }
+
+  @Override
+  public LayoutShadowNode createShadowNodeInstance() {
+    // we use a custom shadow node that emits the width/height of the view
+    // after layout with the updateExtraData method. Without this, we can't generate
+    // a bitmap of the appropriate width/height of the rendered view.
+    return new SizeReportingShadowNode();
+  }
+
+  @Override
+  public void updateExtraData(RMFMarker view, Object extraData) {
+    // This method is called from the shadow node with the width/height of the rendered
+    // marker view.
+    HashMap<String, Float> data = (HashMap<String, Float>) extraData;
+    float width = data.get("width");
+    float height = data.get("height");
+    view.update((int) width, (int) height);
+  }
+
+  @ReactProp(name = "coordinate")
+  public void setCoordinate(RMFMarker view, ReadableMap map) {
+    view.setPosition(map);
+  }
+
+  @ReactProp(name = "anchor")
+  public void setAnchor(RMFMarker view, ReadableMap map) {
+    view.setAnchor(map);
+  }
+
+  @ReactProp(name = "infoWindowAnchor")
+  public void setInfoWindowAnchor(RMFMarker view, ReadableMap map) {
+    view.setInfoWindowAnchor(map);
+  }
+
+  @ReactProp(name = "draggable")
+  public void setDraggable(RMFMarker view, boolean draggable) {
+    view.setDraggable(draggable);
+  }
+
+  @ReactProp(name = "visible")
+  public void setVisible(RMFMarker view, boolean visible) {
+    view.setVisible(visible);
+  }
+
+  @ReactProp(name = "title")
+  public void setTitle(RMFMarker view, String title) {
+    view.setTitle(title);
+  }
+
+  @ReactProp(name = "snippet")
+  public void setSnippet(RMFMarker view, String snippet) {
+    view.setSnippet(snippet);
+  }
+
+  @ReactProp(name = "zIndex")
+  public void setZIndex(RMFMarker view, double zIndex) {
+    view.setZIndex(zIndex);
+  }
+
+  @ReactProp(name = "rotation")
+  public void setRotation(RMFMarker view, double rotation) {
+    view.setRotation(rotation);
+  }
+
+  @ReactProp(name = "icon")
+  public void setIcon(RMFMarker view, ReadableMap data) {
+    String uri = data != null && data.hasKey("uri") ? data.getString("uri") : null;
+    int width = data != null && data.hasKey("width") ? (int) (data.getInt("width") * metrics.density) : 0;
+    int height = data != null && data.hasKey("height") ? (int) (data.getInt("height") * metrics.density) : 0;
+    view.setIcon(uri, width, height);
+  }
+
+  @ReactProp(name = "elevation")
+  public void setElevation(RMFMarker view, double elevation) {
+    view.setElevation(elevation);
+  }
+
+  @ReactProp(name = "userData")
+  public void setUserData(RMFMarker view, ReadableMap userData) {
+    view.setUserData(userData);
+  }
+
+}

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

@@ -0,0 +1,222 @@
+package com.reactnativemap4dmap;
+
+import android.content.Context;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.drawable.Animatable;
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.DataSource;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.drawee.view.DraweeHolder;
+import com.facebook.drawee.interfaces.DraweeController;
+import com.facebook.drawee.controller.ControllerListener;
+import com.facebook.drawee.controller.BaseControllerListener;
+import com.facebook.drawee.generic.GenericDraweeHierarchy;
+import com.facebook.drawee.generic.GenericDraweeHierarchyBuilder;
+import com.facebook.drawee.drawable.ScalingUtils;
+import com.facebook.imagepipeline.image.CloseableImage;
+import com.facebook.imagepipeline.image.ImageInfo;
+import com.facebook.imagepipeline.request.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
+import com.facebook.imagepipeline.image.CloseableStaticBitmap;
+import com.facebook.imagepipeline.core.ImagePipeline;
+
+import vn.map4d.map.core.*;
+import vn.map4d.map.annotations.*;
+
+import androidx.annotation.ColorInt;
+
+import vn.map4d.types.MFLocationCoordinate;
+
+import javax.annotation.Nullable;
+
+public class RMFPOI extends RMFFeature {
+  private MFPOIOptions options;
+  private MFLocationCoordinate position;
+  private String title;
+  private @ColorInt int color;
+  private String subTitle;
+  private String type;
+  private MFBitmapDescriptor iconBitmapDescriptor;
+  private float zIndex;
+  private MFPOI poi;
+
+  private final DraweeHolder<?> logoHolder;
+  private DataSource<CloseableReference<CloseableImage>> dataSource;
+  private final ControllerListener<ImageInfo> mLogoControllerListener =
+    new BaseControllerListener<ImageInfo>() {
+      @Override
+      public void onFinalImageSet(
+          String id,
+          @Nullable final ImageInfo imageInfo,
+          @Nullable Animatable animatable) {
+        CloseableReference<CloseableImage> imageReference = null;
+        try {
+          imageReference = dataSource.getResult();
+          if (imageReference != null) {
+            CloseableImage image = imageReference.get();
+            if (image != null && image instanceof CloseableStaticBitmap) {
+              CloseableStaticBitmap closeableStaticBitmap = (CloseableStaticBitmap) image;
+              Bitmap bitmap = closeableStaticBitmap.getUnderlyingBitmap();
+              if (bitmap != null) {
+                bitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true);
+                iconBitmapDescriptor = MFBitmapDescriptorFactory.fromBitmap(bitmap);
+              }
+            }
+          }
+        } finally {
+          dataSource.close();
+          if (imageReference != null) {
+            CloseableReference.closeSafely(imageReference);
+          }
+        }
+
+        if (RMFPOI.this.poi != null) {
+          RMFPOI.this.poi.setIcon(iconBitmapDescriptor);
+        }
+      }
+    };
+
+  public RMFPOI(Context context) {
+    super(context);
+    this.position = new MFLocationCoordinate(0, 0);
+    this.title = "";
+    this.subTitle = "";
+    this.color = Color.BLACK;
+    this.type = "";
+    this.zIndex = 0.0f;
+    logoHolder = DraweeHolder.create(createDraweeHierarchy(), context);
+    logoHolder.onAttach();
+  }
+
+  private GenericDraweeHierarchy createDraweeHierarchy() {
+    return new GenericDraweeHierarchyBuilder(getResources())
+      .setActualImageScaleType(ScalingUtils.ScaleType.FIT_CENTER)
+      .setFadeDuration(0)
+      .build();
+  }
+
+  public void setCoordinate(ReadableMap data) {
+    this.position = new MFLocationCoordinate(data.getDouble("latitude"), data.getDouble("longitude"));
+    if (poi != null) {
+      poi.setPosition(this.position);
+    }
+  }
+
+  public void setTitle(String title) {
+    this.title = title;
+    if (poi != null) {
+      poi.setTitle(this.title);
+    }
+  }
+
+  public void setColor(@ColorInt int color) {
+    this.color = color;
+    if (poi != null) {
+      poi.setColor(this.color);
+    }
+  }
+
+  public void setSubTitle(String subTitle) {
+    this.subTitle = subTitle;
+    if (poi != null) {
+      poi.setSubTitle(this.subTitle);
+    }
+  }
+
+  public void setType(String type) {
+    this.type = type;
+    if (poi != null) {
+      poi.setType(this.type);
+    }
+  }
+
+  public void setIcon(ReadableMap map) {
+    String uri = null;
+    if (map.hasKey("uri")) {
+      uri = map.getString("uri");
+    }
+
+    if (uri == null) {
+      iconBitmapDescriptor = null;
+    }
+    else if (uri.startsWith("http://") || uri.startsWith("https://") ||
+      uri.startsWith("file://") || uri.startsWith("asset://") || uri.startsWith("data:")) {
+      ImageRequest imageRequest = ImageRequestBuilder
+        .newBuilderWithSource(Uri.parse(uri))
+        .build();
+
+      ImagePipeline imagePipeline = Fresco.getImagePipeline();
+      dataSource = imagePipeline.fetchDecodedImage(imageRequest, this);
+      DraweeController controller = Fresco.newDraweeControllerBuilder()
+        .setImageRequest(imageRequest)
+        .setControllerListener(mLogoControllerListener)
+        .setOldController(logoHolder.getController())
+        .build();
+      logoHolder.setController(controller);
+    }
+    else {
+      iconBitmapDescriptor = ImageUtils.getBitmapDescriptorByName(this, uri);
+      if (iconBitmapDescriptor != null) {
+        int drawableId = ImageUtils.getDrawableResourceByName(this, uri);
+        Bitmap iconBitmap = BitmapFactory.decodeResource(getResources(), drawableId);
+        if (iconBitmap == null) { // VectorDrawable or similar
+          Drawable drawable = getResources().getDrawable(drawableId);
+          iconBitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+          drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
+          Canvas canvas = new Canvas(iconBitmap);
+          drawable.draw(canvas);
+        }
+      }
+    }
+  }
+
+  public void setZIndex(double zIndex) {
+    this.zIndex = (float) zIndex;
+    if (poi != null) {
+      poi.setZIndex(this.zIndex);
+    }
+  }
+
+  public void addToMap(Map4D map) {
+    this.poi = map.addPOI(getOptions());
+  }
+
+  public void removeFromMap(Map4D map) {
+    if (poi == null) {
+      return;
+    }
+    poi.remove();
+    poi = null;
+  }
+
+  public MFPOIOptions getOptions() {
+    if (options == null) {
+      options = new MFPOIOptions();
+    }
+    fillOptions(options);
+    return options;
+  }
+
+  private MFPOIOptions fillOptions(MFPOIOptions options) {
+    options.position(position);
+    options.title(title);
+    options.color(color);
+    options.subtitle(subTitle);
+    options.type(type);
+    options.zIndex(zIndex);
+    options.icon(iconBitmapDescriptor);
+    return options;
+  }
+
+  public Object getFeature() {
+    return poi;
+  }
+}

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

@@ -0,0 +1,119 @@
+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 RMFPOIManager extends ViewGroupManager<RMFPOI> {
+  private static final int k_setCoordinate = 1;
+  private static final int k_setTitle = k_setCoordinate + 1;
+  private static final int k_setTitleColor = k_setTitle + 1;
+  private static final int k_setSubTitle = k_setTitleColor + 1;
+  private static final int k_setType = k_setSubTitle + 1;
+  private static final int k_setIcon = k_setType + 1;
+  private static final int k_setZIndex = k_setIcon + 1;
+
+    @Override
+    public String getName() {
+        return "RMFPOI";
+    }
+
+    @Override
+    protected RMFPOI createViewInstance(ThemedReactContext reactContext) {
+      return new RMFPOI(reactContext);
+    }
+
+    @Override
+    public void receiveCommand(RMFPOI view, int commandId, @Nullable ReadableArray args) {
+      ReadableMap data;
+      switch (commandId) {
+        case k_setCoordinate:
+          data = args.getMap(0);
+          view.setCoordinate(data);
+          break;
+        case k_setTitle:
+          view.setTitle(args.getString(0));
+          break;
+        case k_setTitleColor:
+          view.setColor(args.getInt(0));
+          break;
+        case k_setSubTitle:
+          view.setSubTitle(args.getString(0));
+          break;
+        case k_setType:
+          view.setType(args.getString(0));
+          break;
+        case k_setIcon:
+          view.setIcon(args.getMap(0));
+          break;
+        case k_setZIndex:
+          view.setZIndex(args.getDouble(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("setCoordinate", k_setCoordinate);
+    map.put("setTitle", k_setTitle);
+    map.put("setTitleColor", k_setTitleColor);
+    map.put("setSubTitle", k_setSubTitle);
+    map.put("setPoiType", k_setType);
+    map.put("setZIndex", k_setZIndex);
+    return map;
+  }
+
+  @ReactProp(name = "coordinate")
+  public void setCoordinate(RMFPOI view, ReadableMap map) {
+      view.setCoordinate(map);
+  }
+
+  @ReactProp(name = "title")
+  public void setTitle(RMFPOI view, String title) {
+    view.setTitle(title);
+  }
+
+  @ReactProp(name = "titleColor", customType = "Color")
+  public void setTitleColor(RMFPOI view, @ColorInt int titleColor) {
+    view.setColor(titleColor);
+  }
+
+  @ReactProp(name = "subtitle")
+  public void setSubTitle(RMFPOI view, String subTitle) {
+    view.setSubTitle(subTitle);
+  }
+
+  @ReactProp(name = "icon")
+  public void setIcon(RMFPOI view, ReadableMap icon) {
+    view.setIcon(icon);
+  }
+
+  @ReactProp(name = "poiType")
+  public void setType(RMFPOI view, String poiType) {
+    view.setType(poiType);
+  }
+
+  @ReactProp(name = "zIndex")
+  public void setZIndex(RMFPOI view, double zIndex) {
+    view.setZIndex(zIndex);
+  }
+
+}