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

package/android/src/main/java/org/maplibre/reactnative/components/images/MLRNImages.java

@@ -0,0 +1,234 @@
+package org.maplibre.reactnative.components.images;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.res.ResourcesCompat;
+
+import org.maplibre.android.maps.MapLibreMap;
+import org.maplibre.android.maps.Style;
+import org.maplibre.android.utils.BitmapUtils;
+import org.maplibre.reactnative.R;
+import org.maplibre.reactnative.components.AbstractMapFeature;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+import org.maplibre.reactnative.events.ImageMissingEvent;
+import org.maplibre.reactnative.utils.DownloadMapImageTask;
+import org.maplibre.reactnative.utils.ImageEntry;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class MLRNImages extends AbstractMapFeature {
+    private static Bitmap mImagePlaceholder;
+    Set<String> mCurrentImages;
+    private Map<String, ImageEntry> mImages;
+    private Map<String, BitmapDrawable> mNativeImages;
+    private MLRNImagesManager mManager;
+    private boolean mSendMissingImageEvents = false;
+    private MapLibreMap mMap;
+
+    protected String mID;
+
+    public String getID() {
+        return mID;
+    }
+
+    public void setID(String id) {
+        mID = id;
+    }
+
+    public MLRNImages(Context context, MLRNImagesManager manager) {
+        super(context);
+        mManager = manager;
+        mCurrentImages = new HashSet<>();
+        mImages = new HashMap<>();
+        mNativeImages = new HashMap();
+        if (mImagePlaceholder == null) {
+            mImagePlaceholder = BitmapUtils.getBitmapFromDrawable(ResourcesCompat.getDrawable(context.getResources(), R.drawable.empty_drawable, null));
+        }
+    }
+
+    public void setImages(List<Map.Entry<String, ImageEntry>> images) {
+        Map<String, ImageEntry> newImages = new HashMap<>();
+        for (Map.Entry<String, ImageEntry> entry : images) {
+            String key = entry.getKey();
+            ImageEntry value = entry.getValue();
+            ImageEntry oldValue = mImages.put(key, value);
+            if (oldValue == null) {
+                newImages.put(key, value);
+            }
+        }
+        if (mMap != null && mMap.getStyle() != null) {
+            addImagesToStyle(newImages, mMap);
+        }
+    }
+
+    public void setNativeImages(List<Map.Entry<String, BitmapDrawable>> nativeImages) {
+        Map<String, BitmapDrawable> newImages = new HashMap<>();
+        for (Map.Entry<String, BitmapDrawable> entry : nativeImages) {
+            String key = entry.getKey();
+            BitmapDrawable value = entry.getValue();
+            BitmapDrawable oldValue = mNativeImages.put(key, value);
+            if (oldValue == null) {
+                newImages.put(key, value);
+            }
+        }
+        if (mMap != null && mMap.getStyle() != null) {
+            addNativeImagesToStyle(newImages, mMap);
+        }
+    }
+
+    public void setHasOnImageMissing(boolean value) {
+        mSendMissingImageEvents = value;
+    }
+
+    @Override
+    public void removeFromMap(MLRNMapView mapView) {
+        removeImages(mapView);
+        mMap = null;
+        mNativeImages = new HashMap<>();
+        mImages = new HashMap<>();
+        mCurrentImages = new HashSet<>();
+    }
+
+    private void removeImages(MLRNMapView mapView) {
+        mapView.getStyle(new Style.OnStyleLoaded() {
+            @Override
+            public void onStyleLoaded(@NonNull Style style) {
+            if (hasImages()) {
+                for (Map.Entry<String, ImageEntry> image : mImages.entrySet()) {
+                    style.removeImage(image.getKey());
+                }
+            }
+
+            if (hasNativeImages()) {
+                for (Map.Entry<String, BitmapDrawable> image : mNativeImages.entrySet()) {
+                    style.removeImage(image.getKey());
+                }
+            }
+        }});
+    }
+
+    private boolean hasImages() {
+        return mImages != null && mImages.size() > 0;
+    }
+
+    private boolean hasNativeImages() {
+        return mNativeImages != null && mNativeImages.size() > 0;
+    }
+
+
+    static <K, V> List<Map.Entry<K,V>> entry(K k, V v) {
+        return Collections.singletonList((Map.Entry<K,V>)new AbstractMap.SimpleEntry<K, V>(k, v));
+    }
+
+    public boolean addMissingImageToStyle(@NonNull String id, @NonNull MapLibreMap map) {
+        if (mNativeImages != null) {
+            BitmapDrawable drawable = mNativeImages.get(id);
+            if (drawable != null) {
+                addNativeImages(MLRNImages.entry(id, drawable), map);
+                return true;
+            }
+        }
+        if (mImages != null) {
+            ImageEntry entry = mImages.get(id);
+            if (entry != null) {
+                addRemoteImages(MLRNImages.entry(id, entry), map);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public void addImagesToStyle(Map<String, ImageEntry> images, @NonNull MapLibreMap map) {
+        if (images != null) {
+            addRemoteImages(new ArrayList<>(images.entrySet()), map);
+        }
+    }
+
+    public void addNativeImagesToStyle(Map<String, BitmapDrawable> images, @NonNull MapLibreMap map) {
+        if (images != null) {
+            addNativeImages(new ArrayList<>(images.entrySet()), map);
+        }
+    }
+
+    public void sendImageMissingEvent(@NonNull String id, @NonNull MapLibreMap map) {
+        if (mSendMissingImageEvents) {
+            mManager.handleEvent(ImageMissingEvent.makeImageMissingEvent(this, id));
+        }
+    }
+
+    private boolean hasImage(String imageId, @NonNull MapLibreMap map) {
+        Style style = map.getStyle();
+        return style != null && style.getImage(imageId) != null;
+    }
+
+    @Override
+    public void addToMap(final MLRNMapView mapView) {
+        // Wait for style before adding the source to the map
+        // only then we can pre-load required images / placeholders into the style
+        // before we add the ShapeSource to the map
+        mapView.getStyle(new Style.OnStyleLoaded() {
+            @Override
+            public void onStyleLoaded(@NonNull Style style) {
+                MapLibreMap map = mapView.getMapboxMap();
+                mMap = map;
+                addNativeImagesToStyle(mNativeImages, map);
+                addImagesToStyle(mImages, map);
+                // super.addToMap(mapView);
+            }
+        });
+    }
+
+    private void addNativeImages(@Nullable List<Map.Entry<String, BitmapDrawable>> imageEntries, @NonNull MapLibreMap map) {
+        Style style = map.getStyle();
+        if (style == null || imageEntries == null) return;
+
+        for (Map.Entry<String, BitmapDrawable> imageEntry : imageEntries) {
+            if (!hasImage(imageEntry.getKey(), map)) {
+                style.addImage(imageEntry.getKey(), imageEntry.getValue());
+                mCurrentImages.add(imageEntry.getKey());
+            }
+        }
+    }
+
+    private void addRemoteImages(@Nullable List<Map.Entry<String, ImageEntry>> imageEntries, @NonNull MapLibreMap map) {
+        Style style = map.getStyle();
+        if (style == null || imageEntries == null) return;
+
+        List<Map.Entry<String, ImageEntry>> missingImages = new ArrayList<>();
+
+        // Add image placeholder for images that are not yet available in the style. This way
+        // we can load the images asynchronously and add the ShapeSource to the map without delay.
+        // The same is required when this ShapeSource is updated with new/added images and the
+        // data references them. In which case addMissingImageToStyle will take care of loading
+        // them in a similar way.
+        //
+        // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
+        for (Map.Entry<String, ImageEntry> imageEntry : imageEntries) {
+            if (!hasImage(imageEntry.getKey(), map)) {
+                style.addImage(imageEntry.getKey(), mImagePlaceholder);
+                missingImages.add(imageEntry);
+                mCurrentImages.add(imageEntry.getKey());
+            }
+        }
+
+        if (missingImages.size() > 0) {
+            DownloadMapImageTask task = new DownloadMapImageTask(getContext(), map, null);
+            Map.Entry[] params = missingImages.toArray(new Map.Entry[missingImages.size()]);
+            //noinspection unchecked
+            task.execute(params);
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/images/MLRNImagesManager.java

@@ -0,0 +1,103 @@
+package org.maplibre.reactnative.components.images;
+
+import android.graphics.drawable.BitmapDrawable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+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 org.maplibre.reactnative.components.AbstractEventEmitter;
+import org.maplibre.reactnative.components.AbstractMapFeature;
+import org.maplibre.reactnative.components.styles.sources.MLRNShapeSource;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.utils.ImageEntry;
+import org.maplibre.reactnative.utils.ResourceUtils;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+public class MLRNImagesManager extends AbstractEventEmitter<MLRNImages> {
+    public static final String REACT_CLASS = "MLRNImages";
+
+    private ReactApplicationContext mContext;
+
+    @Override
+    public String getName() {
+        return "MLRNImages";
+    }
+
+
+    public MLRNImagesManager(ReactApplicationContext context) {
+        super(context);
+        mContext = context;
+    }
+
+    @Override
+    public MLRNImages createViewInstance(ThemedReactContext context) {
+        return new MLRNImages(context, this);
+    }
+
+    @ReactProp(name = "id")
+    public void setId(MLRNImages source, String id) {
+        source.setID(id);
+    }
+
+    @ReactProp(name = "images")
+    public void setImages(MLRNImages images, ReadableMap map) {
+        List<Map.Entry<String, ImageEntry>> imagesList = new ArrayList<>();
+
+        ReadableMapKeySetIterator iterator = map.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String imageName = iterator.nextKey();
+            ImageEntry imageEntry = null;
+            if (map.getType(imageName) == ReadableType.Map) {
+                ReadableMap imageMap = map.getMap(imageName);
+                String uri = imageMap.getString("uri");
+                boolean hasScale = imageMap.hasKey("scale") && imageMap.getType("scale") == ReadableType.Number;
+                double scale = hasScale ? imageMap.getDouble("scale") : ImageEntry.defaultScale;
+                imageEntry = new ImageEntry(uri, scale);
+            } else {
+                imageEntry = new ImageEntry(map.getString(imageName));
+            }
+            imagesList.add(new AbstractMap.SimpleEntry<String, ImageEntry>(imageName, imageEntry));
+        }
+
+        images.setImages(imagesList);
+    }
+
+    @ReactProp(name = "hasOnImageMissing")
+    public void setHasOnImageMissing(MLRNImages images, Boolean value) {
+        images.setHasOnImageMissing(value);
+    }
+
+    @ReactProp(name = "nativeImages")
+    public void setNativeImages(MLRNImages images, ReadableArray arr) {
+        List<Map.Entry<String, BitmapDrawable>> resources = new ArrayList<>();
+
+        for (int i = 0; i < arr.size(); i++) {
+            String resourceName = arr.getString(i);
+            BitmapDrawable drawable = (BitmapDrawable) ResourceUtils.getDrawableByName(mContext, resourceName);
+
+            if (drawable != null) {
+                resources.add(new AbstractMap.SimpleEntry<String, BitmapDrawable>(resourceName, drawable));
+            }
+        }
+
+        images.setNativeImages(resources);
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return MapBuilder.<String, String>builder()
+                .put(EventKeys.IMAGES_MISSING, "onImageMissing")
+                .build();
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/location/LocationComponentManager.java

@@ -0,0 +1,158 @@
+package org.maplibre.reactnative.components.location;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+
+import org.maplibre.android.location.LocationComponent;
+import org.maplibre.android.location.LocationComponentActivationOptions;
+import org.maplibre.android.location.LocationComponentOptions;
+import org.maplibre.android.location.OnCameraTrackingChangedListener;
+import org.maplibre.android.location.modes.CameraMode;
+import org.maplibre.android.location.modes.RenderMode;
+import org.maplibre.android.maps.MapLibreMap;
+import org.maplibre.android.maps.Style;
+import org.maplibre.reactnative.R;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+import org.maplibre.reactnative.location.LocationManager;
+
+import androidx.annotation.NonNull;
+
+/**
+ * The LocationComponent on android implements both location tracking and display of user's current location.
+ * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
+ * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
+ */
+public class LocationComponentManager {
+    private MLRNMapView mMapView = null;
+    private MapLibreMap mMap = null;
+
+    private LocationManager mLocationManager = null;
+    private LocationComponent mLocationComponent = null;
+    private Context mContext = null;
+
+    private @RenderMode.Mode int mRenderMode = RenderMode.COMPASS;
+
+    public LocationComponentManager(MLRNMapView mlrnMapView, Context context) {
+        mMapView = mlrnMapView;
+        mMap = mMapView.getMapboxMap();
+        mContext = context;
+
+        mLocationManager = LocationManager.getInstance(context);
+    }
+
+    private boolean mShowUserLocation = false;
+
+    private boolean mFollowUserLocation = false;
+
+    private boolean mShowingUserLocation = false;
+
+    public void showUserLocation(boolean showUserLocation) {
+        mShowUserLocation = showUserLocation;
+        stateChanged();
+    }
+
+    public void setFollowUserLocation(boolean followUserLocation) {
+        mFollowUserLocation = followUserLocation;
+        stateChanged();
+    }
+
+    public void setCameraMode(@CameraMode.Mode int cameraMode) {
+        mLocationComponent.setCameraMode(cameraMode);
+    }
+
+    public void setRenderMode(@RenderMode.Mode int renderMode) {
+        mRenderMode = renderMode;
+        if (mShowingUserLocation) {
+            mLocationComponent.setRenderMode(renderMode);
+        }
+    }
+
+    public void setPreferredFramesPerSecond(int preferredFramesPerSecond) {
+       if(mLocationComponent == null || preferredFramesPerSecond <= 0) {
+            return;
+       }
+
+        mLocationComponent.setMaxAnimationFps(preferredFramesPerSecond);
+    }
+
+
+    public void addOnCameraTrackingChangedListener(OnCameraTrackingChangedListener onCameraTrackingChangedListener) {
+        mLocationComponent.addOnCameraTrackingChangedListener(onCameraTrackingChangedListener);
+    }
+
+    @SuppressLint("MissingPermission")
+    private void stateChanged() {
+        mLocationComponent.setLocationComponentEnabled((mFollowUserLocation || mShowUserLocation));
+
+        if (mShowingUserLocation != mShowUserLocation) {
+            updateShowUserLocation(mShowUserLocation);
+        }
+
+        if (mFollowUserLocation) {
+            if (!mShowUserLocation) {
+                mLocationComponent.setRenderMode(RenderMode.GPS);
+            } else {
+                mLocationComponent.setRenderMode(mRenderMode);
+            }
+            mLocationComponent.onStart();
+        } else {
+            mLocationComponent.setCameraMode(CameraMode.NONE);
+        }
+    }
+
+    public boolean hasLocationComponent() {
+        return (mLocationComponent != null);
+    }
+
+    public void update(@NonNull Style style) {
+        update(mShowUserLocation, style);
+    }
+
+    public void update(boolean displayUserLocation, @NonNull Style style) {
+        Integer tintColor = mMapView.getTintColor();
+
+        if (mLocationComponent == null || tintColor != null ) {
+            mLocationComponent = mMap.getLocationComponent();
+
+            LocationComponentActivationOptions locationComponentActivationOptions = LocationComponentActivationOptions
+                    .builder(mContext, style)
+                    .locationComponentOptions(options(displayUserLocation))
+                    .build();
+            mLocationComponent.activateLocationComponent(locationComponentActivationOptions);
+            mLocationComponent.setLocationEngine(mLocationManager.getEngine());
+            mShowingUserLocation = displayUserLocation;
+        }
+
+        updateShowUserLocation(displayUserLocation);
+    }
+
+    private void updateShowUserLocation(boolean displayUserLocation) {
+        if (mShowingUserLocation != displayUserLocation) {
+            mLocationComponent.applyStyle(options(displayUserLocation));
+            mShowingUserLocation = displayUserLocation;
+        }
+    }
+
+    LocationComponentOptions options(boolean displayUserLocation) {
+        LocationComponentOptions.Builder builder = LocationComponentOptions.builder(mContext);
+        Integer tintColor = mMapView.getTintColor();
+        if (!displayUserLocation) {
+            builder = builder
+                    .padding(mMap.getPadding())
+                    .backgroundDrawable(R.drawable.empty)
+                    .backgroundDrawableStale(R.drawable.empty)
+                    .bearingDrawable(R.drawable.empty)
+                    .foregroundDrawable(R.drawable.empty)
+                    .foregroundDrawableStale(R.drawable.empty)
+                    .gpsDrawable(R.drawable.empty)
+                    .accuracyAlpha(0.0f);
+        } else if (tintColor != null) {
+            builder = builder
+                .enableStaleState(false)
+                .bearingTintColor(tintColor)
+                .foregroundTintColor(tintColor)
+                .accuracyColor(tintColor);
+        }
+        return builder.build();
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/location/MLRNNativeUserLocation.java

@@ -0,0 +1,76 @@
+package org.maplibre.reactnative.components.location;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import androidx.annotation.NonNull;
+
+import org.maplibre.android.location.permissions.PermissionsManager;
+import org.maplibre.android.location.modes.RenderMode;
+import org.maplibre.android.maps.MapLibreMap;
+import org.maplibre.android.maps.OnMapReadyCallback;
+import org.maplibre.android.maps.Style;
+import org.maplibre.reactnative.components.AbstractMapFeature;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+
+public class MLRNNativeUserLocation extends AbstractMapFeature implements OnMapReadyCallback, Style.OnStyleLoaded {
+    private boolean mEnabled = true;
+    private MapLibreMap mMap;
+    private MLRNMapView mMapView;
+    private @RenderMode.Mode int mRenderMode = RenderMode.COMPASS;
+    private int mPreferredFramesPerSecond;
+
+    public MLRNNativeUserLocation(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void addToMap(MLRNMapView mapView) {
+        mEnabled = true;
+        mMapView = mapView;
+        mapView.getMapAsync(this);
+        setRenderMode(mRenderMode);
+        setPreferredFramesPerSecond(mPreferredFramesPerSecond);
+    }
+
+    @Override
+    public void removeFromMap(MLRNMapView mapView) {
+        mEnabled = false;
+        if (mMap != null) mMap.getStyle(this);
+    }
+
+    @SuppressLint("MissingPermission")
+    @Override
+    public void onMapReady(@NonNull MapLibreMap mapboxMap) {
+        mMap = mapboxMap;
+        mapboxMap.getStyle(this);
+    }
+
+    @SuppressLint("MissingPermission")
+    @Override
+    public void onStyleLoaded(@NonNull Style style) {
+        Context context = getContext();
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return;
+        }
+
+        LocationComponentManager locationComponent = mMapView.getLocationComponentManager();
+        locationComponent.update(style);
+        locationComponent.showUserLocation(mEnabled);
+    }
+
+    public void setRenderMode(@RenderMode.Mode int renderMode) {
+        mRenderMode = renderMode;
+        if (mMapView != null) {
+            LocationComponentManager locationComponent = mMapView.getLocationComponentManager();
+            locationComponent.setRenderMode(renderMode);
+        }
+    }
+
+    public void setPreferredFramesPerSecond(int framesPerSecond) {
+        mPreferredFramesPerSecond = framesPerSecond;
+        if (mMapView != null) {
+            LocationComponentManager locationComponent = mMapView.getLocationComponentManager();
+            locationComponent.setPreferredFramesPerSecond(framesPerSecond);
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/location/MLRNNativeUserLocationManager.java

@@ -0,0 +1,40 @@
+package org.maplibre.reactnative.components.location;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import org.maplibre.android.location.modes.RenderMode;
+
+import javax.annotation.Nonnull;
+
+public class MLRNNativeUserLocationManager extends ViewGroupManager<MLRNNativeUserLocation> {
+    public static final String REACT_CLASS = "MLRNNativeUserLocation";
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactProp(name="androidRenderMode")
+    public void setAndroidRenderMode(MLRNNativeUserLocation userLocation, String mode) {
+       if ("compass".equalsIgnoreCase(mode)) {
+           userLocation.setRenderMode(RenderMode.COMPASS);
+        } else if ("gps".equalsIgnoreCase(mode)) {
+           userLocation.setRenderMode(RenderMode.GPS);
+        } else {
+           userLocation.setRenderMode(RenderMode.NORMAL);
+       }
+    }
+
+    @ReactProp(name="androidPreferredFramesPerSecond")
+    public void setPreferredFramesPerSecond(MLRNNativeUserLocation userLocation, int preferredFramesPerSecond) {
+       userLocation.setPreferredFramesPerSecond(preferredFramesPerSecond);
+    }
+
+    @Nonnull
+    @Override
+    protected MLRNNativeUserLocation createViewInstance(@Nonnull ThemedReactContext reactContext) {
+        return new MLRNNativeUserLocation(reactContext);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/mapview/LayerSourceInfo.java

@@ -0,0 +1,59 @@
+package org.maplibre.reactnative.components.mapview;
+
+import org.maplibre.android.style.layers.CircleLayer;
+import org.maplibre.android.style.layers.FillExtrusionLayer;
+import org.maplibre.android.style.layers.FillLayer;
+import org.maplibre.android.style.layers.HeatmapLayer;
+import org.maplibre.android.style.layers.HillshadeLayer;
+import org.maplibre.android.style.layers.Layer;
+import org.maplibre.android.style.layers.LineLayer;
+import org.maplibre.android.style.layers.RasterLayer;
+import org.maplibre.android.style.layers.SymbolLayer;
+
+import javax.annotation.Nullable;
+
+class LayerSourceInfo {
+    final String sourceId;
+
+    @Nullable
+    final String sourceLayerId;
+
+    LayerSourceInfo(Layer layer) {
+        if (layer instanceof CircleLayer) {
+            CircleLayer symbolLayer = (CircleLayer) layer;
+            sourceId = symbolLayer.getSourceId();
+            sourceLayerId = symbolLayer.getSourceLayer();
+        } else if (layer instanceof FillExtrusionLayer) {
+            FillExtrusionLayer fillExtrusionLayer = (FillExtrusionLayer)layer;
+            sourceId = fillExtrusionLayer.getSourceId();
+            sourceLayerId = fillExtrusionLayer.getSourceLayer();
+        } else if (layer instanceof FillLayer) {
+            FillLayer fillLayer = (FillLayer)layer;
+            sourceId = fillLayer.getSourceId();
+            sourceLayerId = fillLayer.getSourceLayer();
+        } else if (layer instanceof HeatmapLayer) {
+            HeatmapLayer heatmapLayer = (HeatmapLayer)layer;
+            sourceId = heatmapLayer.getSourceId();
+            sourceLayerId = heatmapLayer.getSourceLayer();
+        } else if (layer instanceof HillshadeLayer) {
+            HillshadeLayer hillshadeLayer = (HillshadeLayer)layer;
+            sourceId = hillshadeLayer.getSourceId();
+            sourceLayerId = null;
+        } else if (layer instanceof LineLayer) {
+            LineLayer lineLayer = (LineLayer)layer;
+            sourceId = lineLayer.getSourceId();
+            sourceLayerId = lineLayer.getSourceLayer();
+        } else if (layer instanceof RasterLayer) {
+            RasterLayer rasterLayer = (RasterLayer) layer;
+            sourceId = rasterLayer.getSourceId();
+            sourceLayerId = null;
+        } else if (layer instanceof SymbolLayer) {
+            SymbolLayer symbolLayer = (SymbolLayer)layer;
+            sourceId = symbolLayer.getSourceId();
+            sourceLayerId = symbolLayer.getSourceLayer();
+        } else {
+            sourceId = "";
+            sourceLayerId = null;
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/mapview/MLRNAndroidTextureMapView.java

@@ -0,0 +1,13 @@
+package org.maplibre.reactnative.components.mapview;
+
+import android.content.Context;
+import org.maplibre.android.maps.MapLibreMapOptions;
+
+@SuppressWarnings({"MissingPermission"})
+public class MLRNAndroidTextureMapView extends MLRNMapView {
+	public static final String LOG_TAG = "MLRNAndroidTextureMapView";
+	
+    public MLRNAndroidTextureMapView(Context context, MLRNAndroidTextureMapViewManager manager, MapLibreMapOptions options) {
+        super(context, manager, options);
+    }
+}