react-native-mapsforge-vtm-ext-grib 0.2.0

package/android/src/main/java/com/jhotadhari/reactnative/mapsforge/vtm/ext/grib/modules/WeatherOverlay.java

@@ -0,0 +1,343 @@
+package com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.modules;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+
+import com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.NativeWeatherOverlaySpec;
+
+import org.oscim.android.MapView;
+import org.oscim.layers.tile.bitmap.BitmapTileLayer;
+
+import com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.tiles.WeatherGridData;
+import com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.tiles.WeatherTileSource;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+// These are public classes in the parent library react-native-mapsforge-vtm
+import com.jhotadhari.reactnative.mapsforge.vtm.Utils;
+import com.jhotadhari.reactnative.mapsforge.vtm.LayerHelper;
+import com.jhotadhari.reactnative.mapsforge.vtm.LayerZoomBoundsHelper;
+
+public class WeatherOverlay extends NativeWeatherOverlaySpec {
+
+    private final LayerHelper layerHelper;
+    private final LayerZoomBoundsHelper zoomBoundsHelper;
+
+    // In-memory cache of parsed grid data, keyed by dataUrl + "|" + parameter + "|" + timeIndex.
+    // LRU eviction with a reasonable cap — each grid is ~128 KB+, and unbounded
+    // retention across URL/parameter/timestep combinations would cause OOM.
+    private static final int MAX_GRID_CACHE_SIZE = 32;
+    private final Map<String, WeatherGridData> gridCache = new LinkedHashMap<String, WeatherGridData>(
+            16, 0.75f, true  // access-order for LRU
+    ) {
+        @Override
+        protected boolean removeEldestEntry(Map.Entry<String, WeatherGridData> eldest) {
+            return size() > MAX_GRID_CACHE_SIZE;
+        }
+    };
+
+    public WeatherOverlay(ReactApplicationContext reactContext) {
+        super(reactContext);
+        layerHelper = new LayerHelper(this, reactContext);
+        zoomBoundsHelper = new LayerZoomBoundsHelper(this, reactContext);
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getTypedExportedConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put("dataUrl", "");
+        constants.put("parameter", "WIND");
+        constants.put("timeIndex", 0);
+        constants.put("colorMap", "wind");
+        constants.put("opacity", 0.7);
+        constants.put("zoomMin", 1);
+        constants.put("zoomMax", 18);
+        constants.put("enabledZoomMin", 1);
+        constants.put("enabledZoomMax", 18);
+        return constants;
+    }
+
+    // ------------------------------------------------------------------
+    // JS-facing methods (must match the TurboModule spec in JS)
+    // ------------------------------------------------------------------
+
+    @ReactMethod
+    public void createLayer(ReadableMap params, Promise promise) {
+        android.util.Log.d("WeatherOverlay", "createLayer called with params: " + params.toString());
+        try {
+            if (!Utils.rMapHasKey(params, "nativeNodeHandle")) {
+                Utils.promiseReject(promise, "Undefined nativeNodeHandle");
+                return;
+            }
+
+            MapView mapView = Utils.getMapView(
+                getReactApplicationContext(),
+                params.getInt("nativeNodeHandle")
+            );
+            if (null == mapView) {
+                Utils.promiseReject(promise, "Unable to find mapView");
+                return;
+            }
+
+            // Get params, assign defaults.
+            Map<String, Object> defaults = getTypedExportedConstants();
+            String dataUrl = Utils.rMapHasKey(params, "dataUrl")
+                ? params.getString("dataUrl") : (String) defaults.get("dataUrl");
+            String parameter = Utils.rMapHasKey(params, "parameter")
+                ? params.getString("parameter") : (String) defaults.get("parameter");
+            int timeIndex = Utils.rMapHasKey(params, "timeIndex")
+                ? params.getInt("timeIndex") : (int) defaults.get("timeIndex");
+            String colorMap = Utils.rMapHasKey(params, "colorMap")
+                ? params.getString("colorMap") : (String) defaults.get("colorMap");
+            double opacity = Utils.rMapHasKey(params, "opacity")
+                ? params.getDouble("opacity") : (double) defaults.get("opacity");
+            int zoomMin = Utils.rMapHasKey(params, "zoomMin")
+                ? params.getInt("zoomMin") : (int) defaults.get("zoomMin");
+            int zoomMax = Utils.rMapHasKey(params, "zoomMax")
+                ? params.getInt("zoomMax") : (int) defaults.get("zoomMax");
+
+            // Load grid data (cached in memory after first load).
+            // Include timeIndex in the key so different timesteps of the
+            // same URL+parameter are cached independently.
+            String cacheKey = dataUrl + "|" + parameter + "|" + timeIndex;
+            WeatherGridData gridData = gridCache.get(cacheKey);
+            if (gridData == null) {
+                gridData = fetchAndParseGridData(dataUrl, parameter, timeIndex);
+                gridCache.put(cacheKey, gridData);
+            }
+
+            // Create the tile source (HillshadingTileSource pattern).
+            WeatherTileSource tileSource = new WeatherTileSource(
+                zoomMin, zoomMax, gridData, parameter, timeIndex, colorMap
+            );
+
+            // Create the bitmap tile layer.
+            BitmapTileLayer layer = new BitmapTileLayer(
+                mapView.map(), tileSource, (float) opacity
+            );
+
+            // Add to map via the async helper.
+            layerHelper.addLayerAsync(layer, params)
+                .thenAccept(uid -> {
+                    // Clear the map to trigger tile loading for the new layer.
+                    mapView.map().clearMap();
+                    promise.resolve(uid);
+                })
+                .exceptionally(throwable -> {
+                    Utils.promiseReject(promise,
+                        "Unable to add layer: " + throwable.getMessage());
+                    return null;
+                });
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utils.promiseReject(promise, e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void removeLayer(ReadableMap params, Promise promise) {
+        layerHelper.removeLayerAsync(params)
+            .thenRun(() -> {
+                if (Utils.rMapHasKey(params, "uuid")) {
+                    promise.resolve(params.getString("uuid"));
+                } else {
+                    promise.resolve("");
+                }
+            })
+            .exceptionally(t -> {
+                Utils.promiseReject(promise, t.getMessage());
+                return null;
+            });
+    }
+
+    @ReactMethod
+    public void updateEnabledZoomMinMax(ReadableMap params, Promise promise) {
+        try {
+            if (!Utils.rMapHasKey(params, "uuid")
+                || !Utils.rMapHasKey(params, "nativeNodeHandle")) {
+                Utils.promiseReject(promise, "Undefined uuid or nativeNodeHandle");
+                return;
+            }
+            zoomBoundsHelper.updateEnabledZoomMinMax(params, promise);
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utils.promiseReject(promise, e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void setOpacity(ReadableMap params, Promise promise) {
+        try {
+            if (!Utils.rMapHasKey(params, "uuid")
+                || !Utils.rMapHasKey(params, "nativeNodeHandle")) {
+                Utils.promiseReject(promise, "Undefined uuid or nativeNodeHandle");
+                return;
+            }
+
+            MapView mapView = Utils.getMapView(
+                getReactApplicationContext(),
+                params.getInt("nativeNodeHandle")
+            );
+            if (null == mapView) {
+                Utils.promiseReject(promise, "Unable to find mapView");
+                return;
+            }
+
+            double opacity = Utils.rMapHasKey(params, "opacity")
+                ? params.getDouble("opacity")
+                : (double) getTypedExportedConstants().get("opacity");
+
+            // Route through the UI thread — BitmapTileLayer.setBitmapAlpha
+            // triggers a map redraw and must not be called from the bridge
+            // thread (consistent with the core library's threading model).
+            com.facebook.react.bridge.UiThreadUtil.runOnUiThread(() -> {
+                try {
+                    BitmapTileLayer layer = (BitmapTileLayer) layerHelper
+                        .getLayers(params.getInt("nativeNodeHandle"))
+                        .get(params.getString("uuid"));
+
+                    if (null == layer) {
+                        Utils.promiseReject(promise, "Unable to find layer");
+                        return;
+                    }
+
+                    layer.setBitmapAlpha((float) opacity, true);
+                    promise.resolve(params.getString("uuid"));
+                } catch (Exception e) {
+                    Utils.promiseReject(promise, e.getMessage());
+                }
+            });
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utils.promiseReject(promise, e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void setTimeIndex(ReadableMap params, Promise promise) {
+        try {
+            if (!Utils.rMapHasKey(params, "uuid")
+                || !Utils.rMapHasKey(params, "nativeNodeHandle")) {
+                Utils.promiseReject(promise, "Undefined uuid or nativeNodeHandle");
+                return;
+            }
+
+            // Time index changes are handled by the JS side via the
+            // remove+create pattern in WeatherOverlay's recreate useEffect
+            // (timeIndex is in its dependency array). The recreate path
+            // fetches fresh data with the correct cache key and creates a
+            // new WeatherTileSource. This method exists for API symmetry
+            // and future in-place interpolation support.
+            promise.resolve(params.getString("uuid"));
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            Utils.promiseReject(promise, e.getMessage());
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Data loading
+    // ------------------------------------------------------------------
+
+    /**
+     * Fetches a JSON weather grid from a URL and parses it.
+     *
+     * <p>Expected JSON format:
+     * <pre>
+     * {
+     *   "parameter": "WIND",
+     *   "unit": "m/s",
+     *   "timeSteps": [{
+     *     "validTime": "2026-07-03T00:00:00Z",
+     *     "minLat": 48.0, "maxLat": 52.0,
+     *     "minLng": -2.0, "maxLng": 3.0,
+     *     "ni": 20, "nj": 16,
+     *     "values": [0.5, 1.2, ...]
+     *   }]
+     * }
+     * </pre>
+     */
+    private WeatherGridData fetchAndParseGridData(
+        String dataUrl, String parameter, int timeIndex
+    ) {
+        HttpURLConnection connection = null;
+        try {
+            URL url = new URL(dataUrl);
+            connection = (HttpURLConnection) url.openConnection();
+            connection.setConnectTimeout(10000);
+            connection.setReadTimeout(10000);
+
+            BufferedReader reader = new BufferedReader(
+                new InputStreamReader(connection.getInputStream(), "UTF-8")
+            );
+            StringBuilder sb = new StringBuilder();
+            String line;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line);
+            }
+            reader.close();
+
+            JSONObject root = new JSONObject(sb.toString());
+
+            String param = root.optString("parameter", parameter);
+            String unit = root.optString("unit", "");
+
+            JSONArray timeSteps = root.getJSONArray("timeSteps");
+            if (timeIndex < 0 || timeIndex >= timeSteps.length()) {
+                throw new IllegalArgumentException(
+                    "timeIndex " + timeIndex + " out of range [0, " + (timeSteps.length() - 1) + "]"
+                );
+            }
+
+            JSONObject step = timeSteps.getJSONObject(timeIndex);
+
+            double minLat = step.getDouble("minLat");
+            double maxLat = step.getDouble("maxLat");
+            double minLng = step.getDouble("minLng");
+            double maxLng = step.getDouble("maxLng");
+            int ni = step.getInt("ni");
+            int nj = step.getInt("nj");
+
+            JSONArray valuesArr = step.getJSONArray("values");
+            float[] values = new float[valuesArr.length()];
+            for (int i = 0; i < valuesArr.length(); i++) {
+                if (valuesArr.isNull(i)) {
+                    values[i] = Float.NaN;
+                } else {
+                    values[i] = (float) valuesArr.getDouble(i);
+                }
+            }
+
+            return new WeatherGridData(
+                minLat, maxLat, minLng, maxLng, ni, nj, values, param, unit
+            );
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException(
+                "Failed to load weather data from " + dataUrl + ": " + e.toString()
+            );
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+}

package/android/src/main/java/com/jhotadhari/reactnative/mapsforge/vtm/ext/grib/tiles/ColorRamp.java

@@ -0,0 +1,165 @@
+package com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.tiles;
+
+import android.graphics.Color;
+
+/**
+ * Maps numeric weather values to display colors.
+ *
+ * <p>Built-in ramps follow meteorological conventions:
+ * <ul>
+ *   <li><b>temperature</b> — blue → cyan → green → yellow → orange → red</li>
+ *   <li><b>wind</b> — light blue → green → yellow → red → purple</li>
+ *   <li><b>pressure</b> — blue → white → red (diverging, centered on 1013 hPa)</li>
+ *   <li><b>rainfall</b> — transparent → light blue → blue → purple</li>
+ *   <li><b>waves</b> — light cyan → blue → dark blue</li>
+ *   <li><b>grayscale</b> — black → white (generic, for debugging)</li>
+ * </ul>
+ */
+public class ColorRamp {
+
+    /** Color stops: [{value, r, g, b}, ...]. Sorted by value ascending. */
+    private final float[] values;
+    private final int[] colors;
+
+    private ColorRamp(float[] values, int[] colors) {
+        this.values = values;
+        this.colors = colors;
+    }
+
+    /**
+     * Returns the color for a given data value, interpolating between
+     * the nearest stops.
+     */
+    public int getColor(float value) {
+        if (value <= values[0]) return colors[0];
+        if (value >= values[values.length - 1]) return colors[colors.length - 1];
+
+        // Find the bracket.
+        int i = 0;
+        while (i < values.length - 1 && values[i + 1] < value) {
+            i++;
+        }
+
+        float t = (value - values[i]) / (values[i + 1] - values[i]);
+        t = Math.max(0, Math.min(1, t));
+
+        int c0 = colors[i];
+        int c1 = colors[i + 1];
+
+        int r = (int) (Color.red(c0) + (Color.red(c1) - Color.red(c0)) * t);
+        int g = (int) (Color.green(c0) + (Color.green(c1) - Color.green(c0)) * t);
+        int b = (int) (Color.blue(c0) + (Color.blue(c1) - Color.blue(c0)) * t);
+        int a = (int) (Color.alpha(c0) + (Color.alpha(c1) - Color.alpha(c0)) * t);
+
+        // Per-stop alpha is interpolated along with RGB. The layer-level
+        // opacity (set via setOpacity / BitmapTileLayer.setBitmapAlpha)
+        // provides the second multiplier, so users can achieve any effective
+        // opacity by tuning per-stop alpha and layer opacity independently.
+        return Color.argb(a, r, g, b);
+    }
+
+    /**
+     * Returns a built-in color ramp by name.
+     *
+     * @param name One of: "temperature", "wind", "pressure", "rainfall", "waves", "grayscale".
+     * @return The corresponding ColorRamp, or "wind" if the name is unrecognized.
+     */
+    public static ColorRamp forName(String name) {
+        switch (name != null ? name.toLowerCase() : "") {
+            case "temperature":
+                return temperature();
+            case "pressure":
+                return pressure();
+            case "rainfall":
+                return rainfall();
+            case "waves":
+                return waves();
+            case "grayscale":
+                return grayscale();
+            case "wind":
+            default:
+                return wind();
+        }
+    }
+
+    // -- Built-in ramps ---------------------------------------------------
+
+    /** Temperature: -20°C (blue) → 0°C (cyan) → 15°C (green) → 25°C (yellow) → 35°C (red). */
+    private static ColorRamp temperature() {
+        return new ColorRamp(
+            new float[]{-20, 0, 15, 25, 35},
+            new int[]{
+                Color.rgb(0, 0, 255),     // -20°C: blue
+                Color.rgb(0, 200, 255),   // 0°C: cyan
+                Color.rgb(0, 200, 0),     // 15°C: green
+                Color.rgb(255, 255, 0),   // 25°C: yellow
+                Color.rgb(255, 0, 0),     // 35°C: red
+            }
+        );
+    }
+
+    /** Wind speed: 0 m/s (light blue) → 15 m/s (green) → 30 m/s (yellow) → 50 m/s (red) → 70 m/s (purple). */
+    private static ColorRamp wind() {
+        return new ColorRamp(
+            new float[]{0, 15, 30, 50, 70},
+            new int[]{
+                Color.rgb(200, 230, 255), // calm: pale blue
+                Color.rgb(50, 200, 50),   // 15 m/s: green
+                Color.rgb(255, 255, 0),   // 30 m/s: yellow
+                Color.rgb(255, 0, 0),     // 50 m/s: red
+                Color.rgb(128, 0, 128),   // 70 m/s: purple
+            }
+        );
+    }
+
+    /** Pressure: 960 hPa (blue) → 1013 hPa (white) → 1050 hPa (red). Diverging around standard sea-level pressure. */
+    private static ColorRamp pressure() {
+        return new ColorRamp(
+            new float[]{960, 990, 1013, 1036, 1050},
+            new int[]{
+                Color.rgb(0, 0, 200),     // deep low: blue
+                Color.rgb(100, 150, 255), // low: light blue
+                Color.rgb(255, 255, 255), // 1013: white
+                Color.rgb(255, 150, 100), // high: light red
+                Color.rgb(200, 0, 0),     // deep high: red
+            }
+        );
+    }
+
+    /** Rainfall rate: 0 mm/h (transparent) → 1 (light blue) → 5 (blue) → 20 (purple). */
+    private static ColorRamp rainfall() {
+        return new ColorRamp(
+            new float[]{0, 1, 5, 20},
+            new int[]{
+                Color.argb(40, 200, 230, 255),  // trace: very pale
+                Color.rgb(100, 180, 255),        // 1 mm/h: light blue
+                Color.rgb(0, 0, 255),            // 5 mm/h: blue
+                Color.rgb(100, 0, 200),          // 20 mm/h: purple
+            }
+        );
+    }
+
+    /** Wave height: 0m (cyan) → 2m (blue) → 5m (dark blue) → 10m (very dark). */
+    private static ColorRamp waves() {
+        return new ColorRamp(
+            new float[]{0, 2, 5, 10},
+            new int[]{
+                Color.rgb(180, 230, 255), // calm: light cyan
+                Color.rgb(30, 100, 255),  // 2m: blue
+                Color.rgb(0, 0, 120),     // 5m: dark blue
+                Color.rgb(0, 0, 40),      // 10m: very dark
+            }
+        );
+    }
+
+    /** Grayscale: 0 (black) → 100 (white). Generic/debug ramp. */
+    private static ColorRamp grayscale() {
+        return new ColorRamp(
+            new float[]{0, 100},
+            new int[]{
+                Color.rgb(0, 0, 0),
+                Color.rgb(255, 255, 255),
+            }
+        );
+    }
+}

package/android/src/main/java/com/jhotadhari/reactnative/mapsforge/vtm/ext/grib/tiles/WeatherGridData.java

@@ -0,0 +1,103 @@
+package com.jhotadhari.reactnative.mapsforge.vtm.ext.grib.tiles;
+
+/**
+ * In-memory representation of a single time step of gridded weather data.
+ *
+ * <p>The grid is a regular lat/lon grid with {@code ni} columns (longitude)
+ * and {@code nj} rows (latitude). Values are stored in row-major order
+ * (latitude varies slowest). Missing values are represented by {@link Float#NaN}.
+ */
+public class WeatherGridData {
+
+    /** Minimum latitude (southern edge). */
+    public final double minLat;
+    /** Maximum latitude (northern edge). */
+    public final double maxLat;
+    /** Minimum longitude (western edge). */
+    public final double minLng;
+    /** Maximum longitude (eastern edge). */
+    public final double maxLng;
+    /** Number of grid points in the longitude direction. */
+    public final int ni;
+    /** Number of grid points in the latitude direction. */
+    public final int nj;
+    /** Row-major grid values, length = ni * nj. NaN = missing. */
+    public final float[] values;
+
+    /** The human-readable parameter name (e.g. "WIND", "TEMP"). */
+    public final String parameter;
+    /** The unit string (e.g. "m/s", "K", "hPa"). */
+    public final String unit;
+
+    /**
+     * @param minLat  Minimum latitude (southern edge).
+     * @param maxLat  Maximum latitude (northern edge).
+     * @param minLng  Minimum longitude (western edge).
+     * @param maxLng  Maximum longitude (eastern edge).
+     * @param ni      Number of grid points in longitude direction.
+     * @param nj      Number of grid points in latitude direction.
+     * @param values  Row-major float values.
+     * @param parameter Parameter name.
+     * @param unit    Unit string.
+     */
+    public WeatherGridData(
+        double minLat, double maxLat,
+        double minLng, double maxLng,
+        int ni, int nj,
+        float[] values,
+        String parameter,
+        String unit
+    ) {
+        this.minLat = minLat;
+        this.maxLat = maxLat;
+        this.minLng = minLng;
+        this.maxLng = maxLng;
+        this.ni = ni;
+        this.nj = nj;
+        this.values = values;
+        this.parameter = parameter;
+        this.unit = unit;
+    }
+
+    /**
+     * Looks up the grid value at a given geographic position using bilinear
+     * interpolation. Returns {@link Float#NaN} if the position is outside the
+     * grid bounds or if any of the four surrounding grid points are missing.
+     */
+    public float getValueAt(double lat, double lng) {
+        if (lat < minLat || lat > maxLat || lng < minLng || lng > maxLng) {
+            return Float.NaN;
+        }
+
+        // Fractional position within the grid [0..1].
+        double fx = (lng - minLng) / (maxLng - minLng);
+        double fy = (lat - minLat) / (maxLat - minLat);
+
+        // Grid index (floating point).
+        double gi = fx * (ni - 1);
+        double gj = (1.0 - fy) * (nj - 1); // Flip: row 0 is maxLat.
+
+        int i0 = (int) Math.floor(gi);
+        int i1 = Math.min(i0 + 1, ni - 1);
+        int j0 = (int) Math.floor(gj);
+        int j1 = Math.min(j0 + 1, nj - 1);
+
+        float v00 = values[j0 * ni + i0];
+        float v10 = values[j0 * ni + i1];
+        float v01 = values[j1 * ni + i0];
+        float v11 = values[j1 * ni + i1];
+
+        // If any surrounding point is missing, don't interpolate.
+        if (Float.isNaN(v00) || Float.isNaN(v10) || Float.isNaN(v01) || Float.isNaN(v11)) {
+            return Float.NaN;
+        }
+
+        double tx = gi - i0;
+        double ty = gj - j0;
+
+        // Bilinear interpolation.
+        float v0 = (float) (v00 + (v10 - v00) * tx);
+        float v1 = (float) (v01 + (v11 - v01) * tx);
+        return (float) (v0 + (v1 - v0) * ty);
+    }
+}