@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.10

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);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/LocationManager.java

@@ -0,0 +1,164 @@
+package org.maplibre.reactnative.location;
+
+import android.content.Context;
+import android.location.Location;
+import android.os.Looper;
+import android.util.Log;
+
+import org.maplibre.android.location.engine.LocationEngine;
+import org.maplibre.android.location.engine.LocationEngineCallback;
+
+/*
+import com.mapbox.android.core.location.LocationEngineListener;
+import com.mapbox.android.core.location.LocationEnginePriority;
+*/
+
+import org.maplibre.android.location.engine.LocationEngineDefault;
+import org.maplibre.android.location.engine.LocationEngineRequest;
+import org.maplibre.android.location.engine.LocationEngineResult;
+import org.maplibre.android.location.permissions.PermissionsManager;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+@SuppressWarnings({"MissingPermission"})
+public class LocationManager implements LocationEngineCallback<LocationEngineResult> {
+    static final long DEFAULT_FASTEST_INTERVAL_MILLIS = 1000;
+    static final long DEFAULT_INTERVAL_MILLIS = 1000;
+
+    public static final String LOG_TAG = "LocationManager";
+
+    private LocationEngine locationEngine;
+    private Context context;
+    private List<OnUserLocationChange> listeners = new ArrayList<>();
+
+    private float mMinDisplacement = 0;
+    private boolean isActive = false;
+    private Location lastLocation = null;
+
+    private LocationEngineRequest locationEngineRequest = null;
+
+    private static WeakReference<LocationManager> INSTANCE = null;
+
+    public static LocationManager getInstance(Context context) {
+        if (INSTANCE == null) {
+            INSTANCE = new WeakReference<>(new LocationManager(context));
+        }
+        return INSTANCE.get();
+    }
+
+    public interface OnUserLocationChange {
+        void onLocationChange(Location location);
+    }
+
+    private LocationManager(Context context) {
+        this.context = context;
+        this.buildEngineRequest();
+
+    }
+    private void buildEngineRequest() {
+        locationEngine = LocationEngineDefault.INSTANCE.getDefaultLocationEngine(this.context.getApplicationContext());
+        locationEngineRequest = new LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
+                .setFastestInterval(DEFAULT_FASTEST_INTERVAL_MILLIS)
+                .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+                .setDisplacement(mMinDisplacement)
+                .build();
+    }
+
+    public void addLocationListener(OnUserLocationChange listener) {
+        if (!listeners.contains(listener)) {
+            listeners.add(listener);
+        }
+    }
+
+    public void removeLocationListener(OnUserLocationChange listener) {
+        if (listeners.contains(listener)) {
+            listeners.remove(listener);
+        }
+    }
+    public void setMinDisplacement(float minDisplacement) {
+        mMinDisplacement = minDisplacement;
+    }
+    public void enable() {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return;
+        }
+
+        // remove existing listeners
+        locationEngine.removeLocationUpdates(this);
+
+        // refresh location engine request with new values
+        this.buildEngineRequest();
+
+        // add new listeners
+        locationEngine.requestLocationUpdates(
+                locationEngineRequest,
+                this,
+                Looper.getMainLooper()
+        );
+        isActive = true;
+    }
+
+
+    public void disable() {
+        locationEngine.removeLocationUpdates(this);
+        isActive = false;
+    }
+
+    public void dispose() {
+        if (locationEngine == null) {
+            return;
+        }
+        disable();
+        locationEngine.removeLocationUpdates(this);
+    }
+
+    public boolean isActive() {
+        return locationEngine != null && this.isActive;
+    }
+
+    public Location getLastKnownLocation() {
+        if (locationEngine == null) {
+            return null;
+        }
+        return lastLocation;
+    }
+
+
+    public void getLastKnownLocation(LocationEngineCallback<LocationEngineResult> callback) {
+        if (locationEngine == null) {
+            callback.onFailure(new Exception("LocationEngine not initialized"));
+        }
+
+        try {
+            locationEngine.getLastLocation(callback);
+        }
+        catch(Exception exception) {
+            Log.w(LOG_TAG, exception);
+            callback.onFailure(exception);
+        }
+    }
+
+    public LocationEngine getEngine() {
+        return locationEngine;
+    }
+
+    public void onLocationChanged(Location location) {
+        lastLocation = location;
+        for (OnUserLocationChange listener : listeners) {
+            listener.onLocationChange(location);
+        }
+    }
+
+    @Override
+    public void onFailure(Exception exception) {
+        // FMTODO handle this.
+    }
+
+    @Override
+    public void onSuccess(LocationEngineResult result) {
+        onLocationChanged(result.getLastLocation());
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/UserLocation.java

@@ -0,0 +1,59 @@
+package org.maplibre.reactnative.location;
+
+import android.location.Location;
+
+import org.maplibre.android.geometry.LatLng;
+
+public class UserLocation {
+    private Location currentLocation;
+    private Location previousLocation;
+
+    private int userTrackingMode = UserTrackingMode.NONE;
+
+    public UserLocation() {
+        this(null);
+    }
+
+    public UserLocation(Location currentLocation) {
+        this.currentLocation = currentLocation;
+    }
+
+    public Location getCurrentLocation() {
+        return currentLocation;
+    }
+
+    public double getBearing() {
+        if (currentLocation == null) {
+            return 0.0;
+        }
+        return currentLocation.getBearing();
+    }
+
+    public LatLng getCoordinate() {
+        if (currentLocation == null) {
+            return null;
+        }
+
+        return new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude());
+    }
+
+    public void setCurrentLocation(Location currentLocation) {
+        this.previousLocation = this.currentLocation;
+        this.currentLocation = currentLocation;
+    }
+
+    public void setTrackingMode(int userTrackingMode) {
+        this.userTrackingMode = userTrackingMode;
+    }
+
+    public int getTrackingMode() {
+        return userTrackingMode;
+    }
+
+    public float getDistance(Location location) {
+        if (currentLocation == null) {
+            return 0.0f;
+        }
+        return currentLocation.distanceTo(location);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/UserLocationVerticalAlignment.java

@@ -0,0 +1,7 @@
+package org.maplibre.reactnative.location;
+
+public class UserLocationVerticalAlignment {
+    public static final int CENTER = 0;
+    public static final int TOP = 1;
+    public static final int BOTTOM = 2;
+}

package/android/src/main/java/org/maplibre/reactnative/location/UserTrackingMode.java

@@ -0,0 +1,59 @@
+package org.maplibre.reactnative.location;
+
+/*
+import org.maplibre.android.plugins.locationlayer.modes.RenderMode;
+*/
+
+import org.maplibre.android.location.modes.CameraMode;
+import org.maplibre.android.location.modes.RenderMode;
+
+public class UserTrackingMode {
+    public static final int NONE = 0;
+    public static final int FOLLOW = 1;
+    public static final int FollowWithCourse = 2;
+    public static final int FollowWithHeading = 3;
+
+    public static @CameraMode.Mode int getCameraMode(int mode) {
+        switch(mode) {
+            case NONE:
+                return CameraMode.NONE;
+            case FOLLOW:
+                return CameraMode.TRACKING;
+            case FollowWithCourse:
+                return CameraMode.TRACKING_GPS;
+            case FollowWithHeading:
+                return CameraMode.TRACKING_COMPASS;
+        }
+        return CameraMode.NONE;
+    }
+
+    public static boolean isUserGesture(int reason) {
+        return reason == 1 || reason == 2; // user gesture or animation
+    }
+
+    public static String toString(int value) {
+        switch (value) {
+            case UserTrackingMode.FOLLOW:
+                return "normal";
+            case UserTrackingMode.FollowWithCourse:
+                return "course";
+            case UserTrackingMode.FollowWithHeading:
+                return "compass";
+        }
+        return null;
+    }
+
+    public static int fromString(String value) {
+        if (value == null) value = "";
+        switch (value) {
+            case "course":
+                return UserTrackingMode.FollowWithCourse;
+            case "normal":
+                return UserTrackingMode.FOLLOW;
+            case "compass":
+                return UserTrackingMode.FollowWithHeading;
+            default:
+                return UserTrackingMode.FOLLOW;
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/UserTrackingState.java

@@ -0,0 +1,15 @@
+package org.maplibre.reactnative.location;
+
+public class UserTrackingState {
+    // The map view not yet tracked the user location
+    public static final int POSSIBLE = 0;
+
+    // The map view has begun to move to the first user location
+    public static final int BEGAN = 1;
+
+    // The map views begins a significant transition
+    public static final int SIGNIFICANT_TRANSITION = 2;
+
+    // The map view has finished moving to the user location
+    public static final int CHANGED = 3;
+}

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNLocationModule.java

@@ -0,0 +1,158 @@
+package org.maplibre.reactnative.modules;
+
+import android.location.Location;
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import org.maplibre.android.location.engine.LocationEngineCallback;
+import org.maplibre.android.location.engine.LocationEngineResult;
+import org.maplibre.reactnative.events.EventEmitter;
+import org.maplibre.reactnative.events.LocationEvent;
+import org.maplibre.reactnative.location.LocationManager;
+
+@ReactModule(name = MLRNLocationModule.REACT_CLASS)
+public class MLRNLocationModule extends ReactContextBaseJavaModule {
+    public static final String REACT_CLASS = "MLRNLocationModule";
+    public static final String LOCATION_UPDATE = "MapboxUserLocationUpdate";
+
+    private boolean isEnabled;
+    private float mMinDisplacement;
+    private boolean isPaused;
+
+    private LocationManager locationManager;
+
+    private LifecycleEventListener lifecycleEventListener = new LifecycleEventListener() {
+        @Override
+        public void onHostResume() {
+            if (isEnabled) {
+                startLocationManager();
+            }
+        }
+
+        @Override
+        public void onHostPause() {
+            pauseLocationManager();
+        }
+
+        @Override
+        public void onHostDestroy() {
+            stopLocationManager();
+        }
+    };
+
+    private LocationManager.OnUserLocationChange onUserLocationChangeCallback = new LocationManager.OnUserLocationChange() {
+        @Override
+        public void onLocationChange(Location location) {
+            LocationEvent locationEvent = new LocationEvent(location);
+
+            RCTNativeAppEventEmitter emitter = EventEmitter.getModuleEmitter(getReactApplicationContext());
+            if (emitter != null) {
+                emitter.emit(LOCATION_UPDATE, locationEvent.getPayload());
+            }
+        }
+    };
+
+    public MLRNLocationModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        locationManager = LocationManager.getInstance(reactContext);
+        reactContext.addLifecycleEventListener(lifecycleEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+
+    @ReactMethod
+    public void start(float minDisplacement) {
+        isEnabled = true;
+        mMinDisplacement = minDisplacement;
+        startLocationManager();
+    }
+
+    @ReactMethod
+    public void setMinDisplacement(float minDisplacement) {
+        if (mMinDisplacement == minDisplacement) return;
+        mMinDisplacement = minDisplacement;
+        if (isEnabled) {
+
+            // set minimal displacement in the manager
+            locationManager.setMinDisplacement(mMinDisplacement);
+
+            // refresh values in location engine request
+            locationManager.enable();
+        }
+    }
+
+    @ReactMethod
+    public void stop() {
+        stopLocationManager();
+    }
+
+    @ReactMethod
+    public void pause() {
+        pauseLocationManager();
+    }
+
+    @ReactMethod
+    public void getLastKnownLocation(final Promise promise) {
+        locationManager.getLastKnownLocation(
+          new LocationEngineCallback<LocationEngineResult>() {
+              public void onSuccess(LocationEngineResult result) {
+                  Location location = result.getLastLocation();
+                  if (result.getLastLocation() != null) {
+                      LocationEvent locationEvent = new LocationEvent(location);
+                      promise.resolve(locationEvent.getPayload());
+                  } else {
+                      promise.resolve(null);
+                  }
+              }
+              public void onFailure(@NonNull Exception exception) {
+                  promise.reject(exception);
+              }
+          }
+        );
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Set up any upstream listeners or background tasks as necessary
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Remove upstream listeners, stop unnecessary background tasks
+    }
+
+    private void startLocationManager() {
+        locationManager.addLocationListener(onUserLocationChangeCallback);
+        locationManager.setMinDisplacement(mMinDisplacement);
+        locationManager.enable();
+        isPaused = false;
+    }
+
+    private void pauseLocationManager() {
+        if (isPaused) {
+            return;
+        }
+        locationManager.disable();
+        isPaused = true;
+    }
+
+    private void stopLocationManager() {
+        if (!isEnabled) {
+            return;
+        }
+        locationManager.removeLocationListener(onUserLocationChangeCallback);
+        locationManager.dispose();
+        isEnabled = false;
+        isPaused = false;
+    }
+}