@maplibre/maplibre-react-native 10.0.0-alpha.8 → 10.0.0-beta.1

package/android/src/main/java/org/maplibre/reactnative/events/FeatureClickEvent.java

@@ -0,0 +1,75 @@
+package org.maplibre.reactnative.events;
+
+import android.graphics.PointF;
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import org.maplibre.geojson.Feature;
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.reactnative.components.styles.sources.MLRNSource;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.utils.ConvertUtils;
+import org.maplibre.reactnative.utils.GeoJSONUtils;
+
+import java.util.List;
+
+public class FeatureClickEvent extends AbstractEvent {
+    private String mEventKey;
+    private List<Feature> mFeatures;
+    private LatLng mLatLng;
+    private PointF mPoint;
+
+    public FeatureClickEvent(View view, String eventKey, String eventType, List<Feature> features, LatLng latLng, PointF point) {
+        super(view, eventType);
+        mFeatures = features;
+        mEventKey = eventKey;
+        mLatLng = latLng;
+        mPoint = point;
+    }
+
+    @Override
+    public String getKey() {
+        return mEventKey;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap map = Arguments.createMap();
+        WritableArray features = Arguments.createArray();
+
+        for(Feature feature : mFeatures) {
+            features.pushMap(GeoJSONUtils.fromFeature(feature));
+        }
+        map.putArray("features", features);
+
+        WritableMap coordinates = Arguments.createMap();
+        coordinates.putDouble("latitude", mLatLng.getLatitude());
+        coordinates.putDouble("longitude", mLatLng.getLongitude());
+        map.putMap("coordinates", coordinates);
+
+        WritableMap point = Arguments.createMap();
+        point.putDouble("x", mPoint.x);
+        point.putDouble("y", mPoint.y);
+        map.putMap("point", point);
+
+        return map;
+    }
+
+    public static FeatureClickEvent makeShapeSourceEvent(View view, MLRNSource.OnPressEvent event) {
+        return new FeatureClickEvent(view, EventKeys.SHAPE_SOURCE_LAYER_CLICK,
+                EventTypes.SHAPE_SOURCE_LAYER_CLICK, event.features, event.latLng, event.screenPoint);
+    }
+
+    public static FeatureClickEvent makeVectorSourceEvent(View view, MLRNSource.OnPressEvent event) {
+        return new FeatureClickEvent(view, EventKeys.VECTOR_SOURCE_LAYER_CLICK,
+                EventTypes.VECTOR_SOURCE_LAYER_CLICK, event.features, event.latLng, event.screenPoint);
+    }
+
+    public static FeatureClickEvent makeRasterSourceEvent(View view, MLRNSource.OnPressEvent event) {
+        return new FeatureClickEvent(view, EventKeys.RASTER_SOURCE_LAYER_CLICK,
+                EventTypes.RASTER_SOURCE_LAYER_CLICK, event.features, event.latLng, event.screenPoint);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/IEvent.java

@@ -0,0 +1,14 @@
+package org.maplibre.reactnative.events;
+
+import com.facebook.react.bridge.WritableMap;
+
+public interface IEvent {
+    int getID();
+    String getKey();
+    String getType();
+    long getTimestamp();
+    boolean equals(IEvent event);
+    boolean canCoalesce();
+    WritableMap getPayload();
+    WritableMap toJSON();
+}

package/android/src/main/java/org/maplibre/reactnative/events/ImageMissingEvent.java

@@ -0,0 +1,42 @@
+package org.maplibre.reactnative.events;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+
+import android.view.View;
+
+public class ImageMissingEvent extends AbstractEvent {
+    private String mEventKey;
+    private String mImageKey;
+
+    public ImageMissingEvent(View view, String eventKey, String eventType, String imageKey) {
+        super(view, eventType);
+        mImageKey = imageKey;
+        mEventKey = eventKey;
+    }
+
+    @Override
+    public String getKey() {
+        return mEventKey;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap imageMissingProperties = new WritableNativeMap();
+        imageMissingProperties.putString("imageKey", mImageKey);
+        return imageMissingProperties;
+
+    }
+
+    public static ImageMissingEvent makeImageMissingEvent(View view, String imageKey) {
+        return new ImageMissingEvent(view, EventKeys.IMAGES_MISSING,
+                EventTypes.IMAGES_MISSING, imageKey);
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        return false;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/LocationEvent.java

@@ -0,0 +1,100 @@
+package org.maplibre.reactnative.events;
+
+import android.location.Location;
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+
+import java.util.UUID;
+
+public class LocationEvent implements IEvent {
+    private UUID uuid;
+    private MLRNMapView mapView;
+    private Location location;
+
+    public LocationEvent(@NonNull Location location, MLRNMapView mapView) {
+        this.mapView = mapView;
+        this.location = location;
+        this.uuid = UUID.randomUUID();
+    }
+
+    public LocationEvent(Location location) {
+        this(location, null);
+    }
+
+    @Override
+    public int getID() {
+        if (mapView != null) {
+            return mapView.getId();
+        }
+        return -1;
+    }
+
+    public UUID getUUID() {
+        return uuid;
+    }
+
+    @Override
+    public String getKey() {
+        return EventKeys.USER_LOCATION_UPDATE;
+    }
+
+    @Override
+    public String getType() {
+        return EventTypes.USER_LOCATION_UPDATED;
+    }
+
+    @Override
+    public long getTimestamp() {
+        return System.currentTimeMillis();
+    }
+
+    @Override
+    public boolean equals(IEvent event) {
+        LocationEvent other = (LocationEvent) event;
+        return getUUID().equals(other.getUUID());
+    }
+
+    public boolean equals(LocationEvent event) {
+        return uuid.equals(event.getUUID());
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap positionProperties = new WritableNativeMap();
+        WritableMap coords = new WritableNativeMap();
+
+        coords.putDouble("longitude", location.getLongitude());
+        coords.putDouble("latitude", location.getLatitude());
+        coords.putDouble("altitude", location.getAltitude());
+        coords.putDouble("accuracy", location.getAccuracy());
+        // A better solution will be to pull the heading from the compass engine, 
+        // unfortunately the api is not publicly available in the mapbox sdk
+        coords.putDouble("heading", location.getBearing());
+        coords.putDouble("course", location.getBearing());
+        coords.putDouble("speed", location.getSpeed());
+
+        positionProperties.putMap("coords", coords);
+        positionProperties.putDouble("timestamp", location.getTime());
+
+        return positionProperties;
+    }
+
+    @Override
+    public WritableMap toJSON() {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", getType());
+        map.putMap("payload", getPayload());
+        return map;
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        return true;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/MapChangeEvent.java

@@ -0,0 +1,43 @@
+package org.maplibre.reactnative.events;
+
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+import org.maplibre.reactnative.events.constants.EventKeys;
+
+public class MapChangeEvent extends AbstractEvent {
+    private WritableMap mPayload;
+
+    public MapChangeEvent(View view, String eventType) {
+        this(view, eventType, Arguments.createMap());
+    }
+
+    public MapChangeEvent(View view, String eventType, WritableMap payload) {
+        super(view, eventType);
+        mPayload = payload;
+    }
+
+    @Override
+    public String getKey() {
+       return EventKeys.MAP_ONCHANGE;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        // FMTODO
+        WritableMap payloadClone = Arguments.createMap();
+        payloadClone.merge(mPayload);
+        return payloadClone;
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        // Make sure EventDispatcher never merges EventKeys.MAP_ONCHANGE events.
+        // This event name is used to emit events with different
+        // org.maplibre.reactnative.events.constants.EventTypes which are dispatched separately on
+        // the JS side
+        return false;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/MapClickEvent.java

@@ -0,0 +1,47 @@
+package org.maplibre.reactnative.events;
+
+import android.graphics.PointF;
+import androidx.annotation.NonNull;
+import android.view.View;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import org.maplibre.android.geometry.LatLng;
+
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.utils.GeoJSONUtils;
+
+public class MapClickEvent extends AbstractEvent {
+    private LatLng mTouchedLatLng;
+    private PointF mScreenPoint;
+
+    public MapClickEvent(View view, @NonNull LatLng latLng, @NonNull PointF screenPoint) {
+        this(view, latLng, screenPoint, EventTypes.MAP_CLICK);
+    }
+
+    public MapClickEvent(View view, @NonNull LatLng latLng, @NonNull PointF screenPoint, String eventType) {
+        super(view, eventType);
+        mTouchedLatLng = latLng;
+        mScreenPoint = screenPoint;
+    }
+
+    @Override
+    public String getKey() {
+        String eventType = getType();
+
+        if (eventType.equals(EventTypes.MAP_LONG_CLICK)) {
+            return EventKeys.MAP_LONG_CLICK;
+        }
+
+        return EventKeys.MAP_CLICK;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap properties = new WritableNativeMap();
+        properties.putDouble("screenPointX", mScreenPoint.x);
+        properties.putDouble("screenPointY", mScreenPoint.y);
+        return GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/MapUserTrackingModeEvent.java

@@ -0,0 +1,32 @@
+package org.maplibre.reactnative.events;
+
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.location.UserTrackingMode;
+
+public class MapUserTrackingModeEvent extends AbstractEvent {
+    private int mUserTrackingMode;
+
+    public MapUserTrackingModeEvent(View view, int userTrackingMode) {
+        super(view, EventTypes.MAP_USER_TRACKING_MODE_CHANGE);
+        mUserTrackingMode = userTrackingMode;
+    }
+
+    @Override
+    public String getKey() {
+        return EventKeys.MAP_USER_TRACKING_MODE_CHANGE;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap payload = Arguments.createMap();
+        payload.putBoolean("followUserLocation", mUserTrackingMode != UserTrackingMode.NONE);
+        payload.putString("followUserMode", UserTrackingMode.toString(mUserTrackingMode));
+
+        return payload;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/OfflineEvent.java

@@ -0,0 +1,25 @@
+package org.maplibre.reactnative.events;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+public class OfflineEvent extends AbstractEvent {
+    private String mEventKey;
+    private WritableMap mPayload;
+
+    public OfflineEvent(String eventKey, String eventType, WritableMap payload) {
+        super(eventType);
+        mEventKey = eventKey;
+        mPayload = payload;
+    }
+
+    @Override
+    public String getKey() {
+        return mEventKey;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        return mPayload;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/PointAnnotationClickEvent.java

@@ -0,0 +1,42 @@
+package org.maplibre.reactnative.events;
+
+import android.graphics.PointF;
+import androidx.annotation.NonNull;
+import android.view.View;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import org.maplibre.android.plugins.markerview.MarkerView;
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.reactnative.components.annotation.MLRNPointAnnotation;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.utils.ConvertUtils;
+import org.maplibre.reactnative.utils.GeoJSONUtils;
+
+public class PointAnnotationClickEvent extends MapClickEvent {
+    private MLRNPointAnnotation mView;
+    private LatLng mTouchedLatLng;
+    private PointF mScreenPoint;
+
+    public PointAnnotationClickEvent(MLRNPointAnnotation view, @NonNull LatLng latLng, @NonNull PointF screenPoint, String eventType) {
+        super(view, latLng, screenPoint, eventType);
+        mView = view;
+        mTouchedLatLng = latLng;
+        mScreenPoint = screenPoint;
+    }
+
+    @Override
+    public String getKey() {
+        return getType().equals(EventTypes.ANNOTATION_SELECTED) ? EventKeys.POINT_ANNOTATION_SELECTED : EventKeys.POINT_ANNOTATION_DESELECTED;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap properties = new WritableNativeMap();
+        properties.putString("id", mView.getID());
+        properties.putDouble("screenPointX", mScreenPoint.x);
+        properties.putDouble("screenPointY", mScreenPoint.y);
+        return GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/PointAnnotationDragEvent.java

@@ -0,0 +1,51 @@
+package org.maplibre.reactnative.events;
+
+import android.graphics.PointF;
+import androidx.annotation.NonNull;
+import android.view.View;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import org.maplibre.android.plugins.markerview.MarkerView;
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.reactnative.components.annotation.MLRNPointAnnotation;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.utils.ConvertUtils;
+import org.maplibre.reactnative.utils.GeoJSONUtils;
+
+public class PointAnnotationDragEvent extends MapClickEvent {
+    MLRNPointAnnotation mView;
+    private LatLng mTouchedLatLng;
+    private PointF mScreenPoint;
+
+    public PointAnnotationDragEvent(MLRNPointAnnotation view, @NonNull LatLng latLng, @NonNull PointF screenPoint, String eventType) {
+        super(view, latLng, screenPoint, eventType);
+        mView = view;
+        mTouchedLatLng = latLng;
+        mScreenPoint = screenPoint;
+    }
+
+    @Override
+    public String getKey() {
+        String eventType = getType();
+
+        if (eventType.equals(EventTypes.ANNOTATION_DRAG_START)) {
+            return EventKeys.POINT_ANNOTATION_DRAG_START;
+        }
+        if (eventType.equals(EventTypes.ANNOTATION_DRAG_END)) {
+            return EventKeys.POINT_ANNOTATION_DRAG_END;
+        }
+
+        return EventKeys.POINT_ANNOTATION_DRAG;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap properties = new WritableNativeMap();
+        properties.putString("id", mView.getID());
+        properties.putDouble("screenPointX", mScreenPoint.x);
+        properties.putDouble("screenPointY", mScreenPoint.y);
+        return GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/constants/EventKeys.java

@@ -0,0 +1,35 @@
+package org.maplibre.reactnative.events.constants;
+
+public class EventKeys {
+    public static final String NAMESPACE = "rct.mapbox";
+
+    // map events
+    public static final String MAP_CLICK = ns("map.press");
+    public static final String MAP_LONG_CLICK = ns("map.longpress");
+    public static final String MAP_ONCHANGE = ns("map.change");
+    public static final String MAP_ON_LOCATION_CHANGE = ns("map.location.change");
+    public static final String MAP_ANDROID_CALLBACK = ns("map.androidcallback");
+    public static final String MAP_USER_TRACKING_MODE_CHANGE = ns("map.usertrackingmodechange");
+
+    // point annotation events
+    public static final String POINT_ANNOTATION_SELECTED = ns("pointannotation.selected");
+    public static final String POINT_ANNOTATION_DESELECTED = ns("pointannotation.deselected");
+    public static final String POINT_ANNOTATION_DRAG_START = ns("pointannotation.dragstart");
+    public static final String POINT_ANNOTATION_DRAG = ns("pointannotation.drag");
+    public static final String POINT_ANNOTATION_DRAG_END = ns("pointannotation.dragend");
+
+    // source events
+    public static final String SHAPE_SOURCE_LAYER_CLICK = ns("shapesource.layer.pressed");
+    public static final String VECTOR_SOURCE_LAYER_CLICK = ns("vectorsource.layer.pressed");
+    public static final String RASTER_SOURCE_LAYER_CLICK = ns("rastersource.layer.pressed");
+
+    // images event
+    public static final String IMAGES_MISSING = ns("images.missing");
+
+    // location events
+    public static final String USER_LOCATION_UPDATE = ns("user.location.update");
+
+    private static String ns(String name) {
+        return String.format("%s.%s", NAMESPACE, name);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/constants/EventTypes.java

@@ -0,0 +1,47 @@
+package org.maplibre.reactnative.events.constants;
+
+public class EventTypes {
+    // map event types
+    public static final String MAP_CLICK = "press";
+    public static final String MAP_LONG_CLICK = "longpress";
+    public static final String MAP_USER_TRACKING_MODE_CHANGE = "usertrackingmodechange";
+
+    public static final String REGION_WILL_CHANGE = "regionwillchange";
+    public static final String REGION_IS_CHANGING = "regionischanging";
+    public static final String REGION_DID_CHANGE  = "regiondidchange";
+    public static final String USER_LOCATION_UPDATED = "userlocationdupdated";
+
+    public static final String WILL_START_LOADING_MAP = "willstartloadingmap";
+    public static final String DID_FINISH_LOADING_MAP = "didfinishloadingmap";
+    public static final String DID_FAIL_LOADING_MAP = "didfailloadingmap";
+
+    public static final String WILL_START_RENDERING_FRAME = "willstartrenderingframe";
+    public static final String DID_FINISH_RENDERING_FRAME = "didfinishrenderingframe";
+    public static final String DID_FINISH_RENDERING_FRAME_FULLY = "didfinishrenderingframefully";
+
+    public static final String WILL_START_RENDERING_MAP = "willstartrenderingmap";
+    public static final String DID_FINISH_RENDERING_MAP = "didfinishrenderingmap";
+    public static final String DID_FINISH_RENDERING_MAP_FULLY = "didfinishrenderingmapfully";
+
+    public static final String DID_FINISH_LOADING_STYLE = "didfinishloadingstyle";
+
+    // point annotation event types
+    public static final String ANNOTATION_SELECTED = "annotationselected";
+    public static final String ANNOTATION_DESELECTED = "annotationdeselected";
+    public static final String ANNOTATION_DRAG_START = "annotationdragstart";
+    public static final String ANNOTATION_DRAG = "annotationdrag";
+    public static final String ANNOTATION_DRAG_END = "annotationdragend";
+
+    // offline event types
+    public static final String OFFLINE_ERROR = "offlineerror";
+    public static final String OFFLINE_TILE_LIMIT = "offlinetilelimit";
+    public static final String OFFLINE_STATUS = "offlinestatus";
+
+    // shape source event types
+    public static final String SHAPE_SOURCE_LAYER_CLICK = "shapesourcelayerpress";
+    public static final String VECTOR_SOURCE_LAYER_CLICK = "vectorsourcelayerpress";
+    public static final String RASTER_SOURCE_LAYER_CLICK = "rastersourcelayerpress";
+
+    // image missing event type
+    public static final String IMAGES_MISSING = "imagesmissing";
+}

package/android/src/main/java/org/maplibre/reactnative/http/CustomHeadersInterceptor.java

@@ -0,0 +1,38 @@
+package org.maplibre.reactnative.http;
+
+import android.util.Log;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import okhttp3.Interceptor;
+import okhttp3.Request;
+import okhttp3.Response;
+
+public class CustomHeadersInterceptor implements Interceptor {
+
+    public static final CustomHeadersInterceptor INSTANCE = new CustomHeadersInterceptor();
+    private Map<String, String> customHeaders = new HashMap<>();
+
+    public void addHeader(@NotNull final String headerName, @NotNull String headerValue) {
+        customHeaders.put(headerName, headerValue);
+    }
+
+    public void removeHeader(@NotNull final String headerName) {
+        customHeaders.remove(headerName);
+    }
+
+    @Override
+    public Response intercept(@NotNull Chain chain) throws IOException {
+        Request.Builder modifiedHeaderBuilder = chain.request().newBuilder();
+        for (Map.Entry<String, String> entry : customHeaders.entrySet()) {
+            modifiedHeaderBuilder.addHeader(entry.getKey(), entry.getValue());
+        }
+
+        Request request = modifiedHeaderBuilder.build();
+        return chain.proceed(request);
+    }
+}