@maplibre/maplibre-react-native 11.0.0-alpha.2 → 11.0.0-alpha.21

package/android/src/main/java/org/maplibre/reactnative/location/TrackUserLocationMode.kt

@@ -0,0 +1,42 @@
+package org.maplibre.reactnative.location
+
+import org.maplibre.android.location.modes.CameraMode
+
+object TrackUserLocationMode {
+    const val NONE: Int = 0
+    const val DEFAULT: Int = 1
+    const val HEADING: Int = 2
+    const val COURSE: Int = 3
+
+    @CameraMode.Mode
+    fun getCameraMode(mode: Int): Int {
+        return when (mode) {
+            DEFAULT -> CameraMode.TRACKING
+            HEADING -> CameraMode.TRACKING_COMPASS
+            COURSE -> CameraMode.TRACKING_GPS
+            else -> CameraMode.NONE
+        }
+    }
+
+    fun isUserGesture(reason: Int): Boolean {
+        return reason == 1 || reason == 2 // user gesture or animation
+    }
+
+    fun toString(value: Int): String? {
+        return when (value) {
+            DEFAULT -> "default"
+            HEADING -> "heading"
+            COURSE -> "course"
+            else -> null
+        }
+    }
+
+    fun fromString(value: String?): Int {
+        return when (value) {
+            "default" -> DEFAULT
+            "heading" -> HEADING
+            "course" -> COURSE
+            else -> NONE
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/TrackUserLocationState.kt

@@ -0,0 +1,15 @@
+package org.maplibre.reactnative.location
+
+object TrackUserLocationState {
+    // The map view not yet tracked the user location
+    const val POSSIBLE: Int = 0
+
+    // The map view has begun to move to the first user location
+    const val BEGAN: Int = 1
+
+    // The map views begins a significant transition
+    const val SIGNIFICANT_TRANSITION: Int = 2
+
+    // The map view has finished moving to the user location
+    const val CHANGED: Int = 3
+}

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

@@ -0,0 +1,40 @@
+package org.maplibre.reactnative.location
+
+import android.location.Location
+import org.maplibre.android.geometry.LatLng
+
+class UserLocation @JvmOverloads constructor(private var currentLocation: Location? = null) {
+    private var previousLocation: Location? = null
+
+    var trackingMode: Int = TrackUserLocationMode.NONE
+
+    fun getCurrentLocation(): Location? {
+        return currentLocation
+    }
+
+
+    val coordinate: LatLng?
+        get() {
+            if (currentLocation == null) {
+                return null
+            }
+
+            return LatLng(
+                currentLocation!!.getLatitude(), currentLocation!!.getLongitude()
+            )
+        }
+
+    val bearing: Double
+        get() {
+            if (currentLocation == null) {
+                return 0.0
+            }
+
+            return currentLocation!!.getBearing().toDouble()
+        }
+
+    fun setCurrentLocation(currentLocation: Location?) {
+        this.previousLocation = this.currentLocation
+        this.currentLocation = currentLocation
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/engine/DefaultLocationEngineProvider.kt

@@ -0,0 +1,18 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import android.util.Log
+import org.maplibre.android.location.engine.LocationEngine
+import org.maplibre.android.location.engine.LocationEngineDefault.getDefaultLocationEngine
+
+class DefaultLocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        val locationEngine = getDefaultLocationEngine(context.applicationContext)
+        Log.d(LOG_TAG, "DefaultLocationEngine will be used.")
+        return locationEngine
+    }
+
+    companion object {
+        private const val LOG_TAG = "DefaultLocationEngineProvider"
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/location/engine/LocationEngineProvidable.kt

@@ -0,0 +1,8 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import org.maplibre.android.location.engine.LocationEngine
+
+interface LocationEngineProvidable {
+    fun getLocationEngine(context: Context): LocationEngine
+}

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

@@ -0,0 +1,174 @@
+package org.maplibre.reactnative.modules
+
+import android.Manifest
+import android.location.Location
+import android.os.Build
+import androidx.annotation.RequiresPermission
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineResult
+import org.maplibre.reactnative.NativeLocationModuleSpec
+import org.maplibre.reactnative.location.LocationManager
+import org.maplibre.reactnative.location.LocationManager.OnUserLocationChange
+
+class MLRNLocationModule(reactContext: ReactApplicationContext) :
+    NativeLocationModuleSpec(reactContext) {
+    companion object {
+        const val NAME = "MLRNLocationModule"
+    }
+
+    override fun getName() = NAME
+
+    private var isEnabled = false
+    private var minDisplacement = 0f
+    private var isPaused = false
+
+    private val locationManager: LocationManager = LocationManager.getInstance(reactContext)
+
+    private val lifecycleEventListener: LifecycleEventListener = object : LifecycleEventListener {
+        @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+        override fun onHostResume() {
+            if (isEnabled) {
+                startLocationManager()
+            }
+        }
+
+        override fun onHostPause() {
+            pauseLocationManager()
+        }
+
+        override fun onHostDestroy() {
+            stopLocationManager()
+        }
+    }
+
+    private val onUserLocationChangeCallback: OnUserLocationChange = object : OnUserLocationChange {
+        override fun onLocationChange(location: Location) {
+            emitOnUpdate(locationToGeolocationPosition(location))
+        }
+    }
+
+    init {
+        reactContext.addLifecycleEventListener(lifecycleEventListener)
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun start() {
+        isEnabled = true
+        startLocationManager()
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun setMinDisplacement(minDisplacement: Double) {
+        if (this.minDisplacement == minDisplacement.toFloat()) return
+
+        this.minDisplacement = minDisplacement.toFloat()
+        if (isEnabled) {
+            locationManager.setMinDisplacement(this.minDisplacement)
+            locationManager.enable()
+        }
+    }
+
+    override fun stop() {
+        stopLocationManager()
+    }
+
+    fun pause() {
+        pauseLocationManager()
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    override fun getCurrentPosition(promise: Promise) {
+        locationManager.getLastKnownLocation(object :
+            LocationEngineCallback<LocationEngineResult?> {
+            override fun onSuccess(result: LocationEngineResult?) {
+                val location = result?.lastLocation
+
+                if (location != null) {
+                    promise.resolve(locationToGeolocationPosition(location))
+                } else {
+                    promise.resolve(null)
+                }
+            }
+
+            override fun onFailure(exception: Exception) {
+                promise.reject(exception)
+            }
+        })
+    }
+
+    override fun requestPermissions(promise: Promise) {
+        // On Android, permissions are handled at the JS level using PermissionsAndroid
+        promise.resolve(null)
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    private fun startLocationManager() {
+        locationManager.addLocationListener(onUserLocationChangeCallback)
+        locationManager.setMinDisplacement(minDisplacement)
+        locationManager.enable()
+        isPaused = false
+    }
+
+    private fun pauseLocationManager() {
+        if (isPaused) {
+            return
+        }
+
+        locationManager.disable()
+        isPaused = true
+    }
+
+    private fun stopLocationManager() {
+        if (!isEnabled) {
+            return
+        }
+
+        locationManager.removeLocationListener(onUserLocationChangeCallback)
+        locationManager.dispose()
+        isEnabled = false
+        isPaused = false
+    }
+
+    private fun locationToGeolocationPosition(location: Location): WritableMap {
+        val coords: WritableMap = WritableNativeMap()
+
+        coords.putDouble("longitude", location.longitude)
+        coords.putDouble("latitude", location.latitude)
+        coords.putDouble("accuracy", location.accuracy.toDouble())
+
+        if (location.hasAltitude()) {
+            coords.putDouble("altitude", location.altitude)
+        } else {
+            coords.putNull("altitude")
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && location.hasVerticalAccuracy()) {
+            coords.putDouble("altitudeAccuracy", location.verticalAccuracyMeters.toDouble())
+        } else {
+            coords.putNull("altitudeAccuracy")
+        }
+
+        if (location.hasBearing()) {
+            coords.putDouble("heading", location.bearing.toDouble())
+        } else {
+            coords.putNull("heading")
+        }
+
+        if (location.hasSpeed()) {
+            coords.putDouble("speed", location.speed.toDouble())
+        } else {
+            coords.putNull("speed")
+        }
+
+        val geolocationPosition: WritableMap = WritableNativeMap()
+        geolocationPosition.putMap("coords", coords)
+        geolocationPosition.putDouble("timestamp", location.time.toDouble())
+
+        return geolocationPosition
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNLogModule.kt

@@ -0,0 +1,99 @@
+package org.maplibre.reactnative.modules
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import org.maplibre.android.log.Logger
+import org.maplibre.android.log.LoggerDefinition
+import org.maplibre.reactnative.NativeLogModuleSpec
+
+class MLRNLogModule(reactContext: ReactApplicationContext) : NativeLogModuleSpec(
+    reactContext
+) {
+
+    companion object {
+        const val NAME: String = "MLRNLogModule"
+    }
+
+    override fun getName() = NAME
+
+
+    init {
+        Logger.setVerbosity(Logger.WARN)
+
+        Logger.setLoggerDefinition(object : LoggerDefinition {
+            override fun v(tag: String, msg: String) {
+                Log.v(tag, msg)
+                onLog("verbose", tag, msg)
+            }
+
+            override fun v(tag: String, msg: String, tr: Throwable) {
+                Log.v(tag, msg, tr)
+                onLog("verbose", tag, msg)
+            }
+
+            override fun d(tag: String, msg: String) {
+                Log.d(tag, msg)
+                onLog("debug", tag, msg)
+            }
+
+            override fun d(tag: String, msg: String, tr: Throwable) {
+                Log.d(tag, msg, tr)
+                onLog("debug", tag, msg)
+            }
+
+            override fun i(tag: String, msg: String) {
+                Log.i(tag, msg)
+                onLog("info", tag, msg)
+            }
+
+            override fun i(tag: String, msg: String, tr: Throwable) {
+                Log.i(tag, msg, tr)
+                onLog("info", tag, msg)
+            }
+
+            override fun w(tag: String, msg: String) {
+                Log.w(tag, msg)
+                onLog("warn", tag, msg)
+            }
+
+            override fun w(tag: String, msg: String, tr: Throwable) {
+                Log.w(tag, msg, tr)
+                onLog("warn", tag, msg)
+            }
+
+            override fun e(tag: String, msg: String) {
+                Log.e(tag, msg)
+                onLog("error", tag, msg)
+            }
+
+            override fun e(tag: String, msg: String, tr: Throwable) {
+                Log.e(tag, msg, tr)
+                onLog("error", tag, msg)
+            }
+        })
+    }
+
+
+    override fun setLogLevel(level: String) {
+        @Logger.LogLevel val logLevel = when (level) {
+            "error" -> Logger.ERROR
+            "warn" -> Logger.WARN
+            "info" -> Logger.INFO
+            "debug" -> Logger.DEBUG
+            "verbose" -> Logger.VERBOSE
+            else -> Logger.NONE
+        }
+        Logger.setVerbosity(logLevel)
+    }
+
+
+    fun onLog(level: String, tag: String, msg: String) {
+        val event = Arguments.createMap()
+        event.putString("level", level)
+        event.putString("tag", tag)
+        event.putString("message", msg)
+
+        emitOnLog(event)
+    }
+}

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

@@ -3,20 +3,15 @@ package org.maplibre.reactnative.modules;
 import android.os.Handler;
 import android.util.Log;
 
-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.common.MapBuilder;
 import com.facebook.react.module.annotations.ReactModule;
+
 import org.maplibre.android.MapLibre;
-import org.maplibre.android.WellKnownTileServer;
-import org.maplibre.reactnative.components.camera.constants.CameraMode;
-import org.maplibre.reactnative.components.styles.sources.MLRNSource;
-import org.maplibre.reactnative.events.constants.EventTypes;
+import org.maplibre.reactnative.components.sources.MLRNSource;
 import org.maplibre.reactnative.http.CustomHeadersInterceptor;
-import org.maplibre.reactnative.location.UserLocationVerticalAlignment;
-import org.maplibre.reactnative.location.UserTrackingMode;
 
 import okhttp3.Dispatcher;
 import okhttp3.OkHttpClient;
@@ -61,45 +56,6 @@ public class MLRNModule extends ReactContextBaseJavaModule {
         Map<String, String> styleURLS = new HashMap<>();
         styleURLS.put("Default", DEFAULT_STYLE_URL);
 
-        // events
-        Map<String, String> eventTypes = new HashMap<>();
-        eventTypes.put("MapClick", EventTypes.MAP_CLICK);
-        eventTypes.put("MapLongClick", EventTypes.MAP_LONG_CLICK);
-        eventTypes.put("RegionWillChange", EventTypes.REGION_WILL_CHANGE);
-        eventTypes.put("RegionIsChanging", EventTypes.REGION_IS_CHANGING);
-        eventTypes.put("RegionDidChange", EventTypes.REGION_DID_CHANGE);
-        eventTypes.put("UserLocationUpdated", EventTypes.USER_LOCATION_UPDATED);
-        eventTypes.put("WillStartLoadingMap", EventTypes.WILL_START_LOADING_MAP);
-        eventTypes.put("DidFinishLoadingMap", EventTypes.DID_FINISH_LOADING_MAP);
-        eventTypes.put("DidFailLoadingMap", EventTypes.DID_FAIL_LOADING_MAP);
-        eventTypes.put("WillStartRenderingFrame", EventTypes.WILL_START_RENDERING_FRAME);
-        eventTypes.put("DidFinishRenderingFrame", EventTypes.DID_FINISH_RENDERING_FRAME);
-        eventTypes.put("DidFinishRenderingFrameFully", EventTypes.DID_FINISH_RENDERING_FRAME_FULLY);
-        eventTypes.put("WillStartRenderingMap", EventTypes.WILL_START_RENDERING_MAP);
-        eventTypes.put("DidFinishRenderingMap", EventTypes.DID_FINISH_RENDERING_MAP);
-        eventTypes.put("DidFinishRenderingMapFully", EventTypes.DID_FINISH_RENDERING_MAP_FULLY);
-        eventTypes.put("DidFinishLoadingStyle", EventTypes.DID_FINISH_LOADING_STYLE);
-
-        // user tracking modes
-        Map<String, Integer> userTrackingModes = new HashMap<>();
-        userTrackingModes.put("None", UserTrackingMode.NONE);
-        userTrackingModes.put("Follow", UserTrackingMode.FOLLOW);
-        userTrackingModes.put("FollowWithCourse", UserTrackingMode.FollowWithCourse);
-        userTrackingModes.put("FollowWithHeading", UserTrackingMode.FollowWithHeading);
-
-        // user location vertical alignment
-        Map<String, Integer> userLocationVerticalAlignment = new HashMap<>();
-        userLocationVerticalAlignment.put("Center", UserLocationVerticalAlignment.CENTER);
-        userLocationVerticalAlignment.put("Top", UserLocationVerticalAlignment.TOP);
-        userLocationVerticalAlignment.put("Bottom", UserLocationVerticalAlignment.BOTTOM);
-
-        // camera modes
-        Map<String, Integer> cameraModes = new HashMap<>();
-        cameraModes.put("Flight", CameraMode.FLIGHT);
-        cameraModes.put("Ease", CameraMode.EASE);
-        cameraModes.put("Linear", CameraMode.LINEAR);
-        cameraModes.put("None", CameraMode.NONE);
-
         // style source constants
         Map<String, String> styleSourceConsts = new HashMap<>();
         styleSourceConsts.put("DefaultSourceID", MLRNSource.DEFAULT_ID);
@@ -115,20 +71,11 @@ public class MLRNModule extends ReactContextBaseJavaModule {
         offlineModuleCallbackNames.put("Error", MLRNOfflineModule.OFFLINE_ERROR);
         offlineModuleCallbackNames.put("Progress", MLRNOfflineModule.OFFLINE_PROGRESS);
 
-        // location module callback names
-        Map<String, String> locationModuleCallbackNames = new HashMap<>();
-        locationModuleCallbackNames.put("Update", MLRNLocationModule.LOCATION_UPDATE);
-
         return MapBuilder.<String, Object>builder()
                 .put("StyleURL", styleURLS)
-                .put("EventTypes", eventTypes)
-                .put("UserTrackingModes", userTrackingModes)
-                .put("UserLocationVerticalAlignment", userLocationVerticalAlignment)
-                .put("CameraModes", cameraModes)
                 .put("StyleSource", styleSourceConsts)
                 .put("OfflinePackDownloadState", offlinePackDownloadStates)
                 .put("OfflineCallbackName", offlineModuleCallbackNames)
-                .put("LocationCallbackName", locationModuleCallbackNames)
                 .build();
     }
 

package/android/src/main/java/org/maplibre/reactnative/modules/MLRNSnapshotModule.kt

@@ -17,8 +17,6 @@ import org.maplibre.geojson.Point
 import org.maplibre.reactnative.NativeSnapshotModuleSpec
 import org.maplibre.reactnative.utils.BitmapUtils
 import org.maplibre.reactnative.utils.GeoJSONUtils
-import java.io.IOException
-import java.io.OutputStream
 import java.util.UUID
 
 @ReactModule(name = MLRNSnapshotModule.NAME)
@@ -33,15 +31,14 @@ class MLRNSnapshotModule(reactContext: ReactApplicationContext) :
     private val context: ReactApplicationContext = reactContext
 
     // Prevent garbage collection
-    private val snapshotterMap: MutableMap<String, MapSnapshotter> =
-        HashMap<String, MapSnapshotter>()
+    private val snapshotterMap: MutableMap<String, MapSnapshotter> = HashMap()
 
     override fun takeSnap(jsOptions: ReadableMap, promise: Promise) {
         org.maplibre.android.storage.FileSource.getInstance(context).activate()
 
         context.runOnUiQueueThread {
             val snapshotterID = UUID.randomUUID().toString()
-            val snapshotter: MapSnapshotter = MapSnapshotter(context, getOptions(jsOptions))
+            val snapshotter = MapSnapshotter(context, getOptions(jsOptions))
             snapshotterMap[snapshotterID] = snapshotter
             snapshotter.start(object :
                 MapSnapshotter.SnapshotReadyCallback {
@@ -114,15 +111,4 @@ class MLRNSnapshotModule(reactContext: ReactApplicationContext) :
 
         return options
     }
-
-    private fun closeSnapshotOutputStream(outputStream: OutputStream?) {
-        if (outputStream == null) {
-            return
-        }
-        try {
-            outputStream.close()
-        } catch (e: IOException) {
-            e.localizedMessage?.let { Log.w(NAME, it) }
-        }
-    }
 }

package/android/src/main/java/org/maplibre/reactnative/utils/ConvertUtils.java

@@ -203,15 +203,8 @@ public class ConvertUtils {
         return list;
     }
 
-    public static PointF toPointF(ReadableArray array) {
-        PointF pointF = new PointF();
-
-        if (array == null) {
-            return pointF;
-        }
-
-        pointF.set((float)array.getDouble(0), (float)array.getDouble(1));
-        return pointF;
+    public static PointF toPointF(ReadableMap map) {
+        return new PointF((float) map.getDouble("locationX"), (float) map.getDouble("locationY"));
     }
 
     public static RectF toRectF(ReadableArray array) {

package/android/src/main/java/org/maplibre/reactnative/utils/DownloadMapImageTask.java

@@ -33,7 +33,7 @@ import java.util.Map;
 
 import javax.annotation.Nullable;
 
-public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry>, Void, List<Map.Entry<String, Bitmap>>> {
+public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry>, Void, List<Map.Entry<String, DownloadedImage>>> {
     public static final String LOG_TAG = "DownloadMapImageTask";
 
     private WeakReference<Context> mContext;
@@ -55,8 +55,8 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
 
     @SafeVarargs
     @Override
-    protected final List<Map.Entry<String, Bitmap>> doInBackground(Map.Entry<String, ImageEntry>... objects) {
-        List<Map.Entry<String, Bitmap>> images = new ArrayList<>();
+    protected final List<Map.Entry<String, DownloadedImage>> doInBackground(Map.Entry<String, ImageEntry>... objects) {
+        List<Map.Entry<String, DownloadedImage>> images = new ArrayList<>();
 
         Context context = mContext.get();
         if (context == null) return images;
@@ -95,7 +95,7 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
                                 // the fresco reference.
                                 .copy(Bitmap.Config.ARGB_8888, true);
                             bitmap.setDensity((int) ((double) DisplayMetrics.DENSITY_DEFAULT * imageEntry.getScaleOr(1.0)));
-                            images.add(new AbstractMap.SimpleEntry<>(object.getKey(), bitmap));
+                            images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
                         } else {
                             FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
                         }
@@ -114,7 +114,7 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
                 // local asset required from JS require('image.png') or import icon from 'image.png' while in release mode
                 Bitmap bitmap = BitmapUtils.getBitmapFromResource(context, uri, getBitmapOptions(metrics, imageEntry.scale));
                 if (bitmap != null) {
-                    images.add(new AbstractMap.SimpleEntry<>(object.getKey(), bitmap));
+                    images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
                 } else {
                     FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
                 }
@@ -125,16 +125,14 @@ public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry
     }
 
     @Override
-    protected void onPostExecute(List<Map.Entry<String, Bitmap>> images) {
+    protected void onPostExecute(List<Map.Entry<String, DownloadedImage>> images) {
         MapLibreMap map = mMap.get();
         if (map != null && images != null && images.size() > 0) {
             Style style = map.getStyle();
             if (style != null) {
-                HashMap<String, Bitmap> bitmapImages = new HashMap<>();
-                for (Map.Entry<String, Bitmap> image : images) {
-                    bitmapImages.put(image.getKey(), image.getValue());
+                for (Map.Entry<String, DownloadedImage> image : images) {
+                    style.addImage(image.getKey(), image.getValue().bitmap(), image.getValue().info().sdf);
                 }
-                style.addImages(bitmapImages);
             }
         }
 

package/android/src/main/java/org/maplibre/reactnative/utils/DownloadedImage.java

@@ -0,0 +1,6 @@
+package org.maplibre.reactnative.utils;
+
+import android.graphics.Bitmap;
+
+public record DownloadedImage(String name, Bitmap bitmap, ImageEntry info) {
+}