@aguacerowx/react-native 0.0.42 → 0.0.44

package/lib/module/android/src/main/java/com/aguacerowx/reactnative/SatelliteLayerView.java

@@ -0,0 +1,355 @@
+package com.aguacerowx.reactnative;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.mapbox.maps.LayerPosition;
+import com.mapbox.maps.MapView;
+import com.mapbox.maps.MapboxMap;
+import com.mapbox.maps.Style;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import okhttp3.Call;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+
+/**
+ * Hosts {@link SatelliteLayer} on the app {@link MapView} (Android satellite path — parity with mapsgl
+ * {@code WeatherLayerManager} + {@code SatelliteShaderManager}).
+ */
+public class SatelliteLayerView extends FrameLayout {
+
+    private static final String TAG = "AguaceroSatelliteView";
+
+    private final SatelliteLayer satelliteLayer;
+    private final String layerId;
+    private MapView mapView;
+    private boolean isLayerAdded = false;
+    private String belowLayerID = null;
+
+    /** Concurrent fetch+decode so the priority frame is not blocked behind the rest of the timeline. */
+    private final ExecutorService satDecodeExecutor =
+            Executors.newFixedThreadPool(
+                    4,
+                    r -> {
+                        Thread t = new Thread(r, "aguacero-satellite-decode");
+                        t.setPriority(Thread.NORM_PRIORITY - 1);
+                        return t;
+                    });
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private final AtomicInteger decodeGeneration = new AtomicInteger(0);
+
+    private volatile String lastRunKey = null;
+
+    private final Set<Long> fetchInFlight =
+            Collections.newSetFromMap(new ConcurrentHashMap<Long, Boolean>());
+
+    private static final OkHttpClient HTTP =
+            new OkHttpClient.Builder()
+                    .followRedirects(true)
+                    .followSslRedirects(true)
+                    .build();
+
+    public SatelliteLayerView(@NonNull ThemedReactContext context) {
+        super(context);
+        this.satelliteLayer = new SatelliteLayer();
+        this.layerId = AguaceroStyleLayerIds.SATELLITE_CUSTOM_LAYER;
+    }
+
+    public void setBelowID(String belowID) {
+        this.belowLayerID = belowID;
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        findMapViewAndAddLayer();
+    }
+
+    private void findMapViewAndAddLayer() {
+        if (mapView != null) {
+            Style existing = mapView.getMapboxMap().getStyle();
+            if (existing != null && existing.isStyleLoaded() && existing.styleLayerExists(layerId)) {
+                isLayerAdded = true;
+                return;
+            }
+        }
+
+        Activity activity = ((ThemedReactContext) getContext()).getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+        View rootView = activity.findViewById(android.R.id.content);
+        if (rootView == null) {
+            return;
+        }
+        MapView foundMap = findMapViewRecursive(rootView);
+        if (foundMap == null) {
+            return;
+        }
+        this.mapView = foundMap;
+        MapboxMap mapboxMap = mapView.getMapboxMap();
+        Style.OnStyleLoaded styleLoadedCallback =
+                style -> {
+                    if (!style.styleLayerExists(layerId)) {
+                        LayerPosition position = null;
+                        if (style.styleLayerExists(AguaceroStyleLayerIds.WEATHER_GRID_CUSTOM_LAYER)) {
+                            position =
+                                    new LayerPosition(
+                                            AguaceroStyleLayerIds.WEATHER_GRID_CUSTOM_LAYER, null, null);
+                        } else if (this.belowLayerID != null && style.styleLayerExists(this.belowLayerID)) {
+                            position = new LayerPosition(null, this.belowLayerID, null);
+                        }
+                        style.addStyleCustomLayer(layerId, satelliteLayer, position);
+                        isLayerAdded = true;
+                        triggerRepaint();
+                    }
+                };
+        Style currentStyle = mapboxMap.getStyle();
+        if (currentStyle != null && currentStyle.isStyleLoaded()) {
+            styleLoadedCallback.onStyleLoaded(currentStyle);
+        } else {
+            mapboxMap.getStyle(styleLoadedCallback);
+        }
+    }
+
+    private MapView findMapViewRecursive(View view) {
+        if (view instanceof MapView) return (MapView) view;
+        if (view instanceof ViewGroup) {
+            ViewGroup vg = (ViewGroup) view;
+            for (int i = 0; i < vg.getChildCount(); i++) {
+                MapView f = findMapViewRecursive(vg.getChildAt(i));
+                if (f != null) return f;
+            }
+        }
+        return null;
+    }
+
+    private void triggerRepaint() {
+        if (mapView != null) mapView.post(mapView.getMapboxMap()::triggerRepaint);
+    }
+
+    static final class FrameClass {
+        final boolean trueColor;
+        @NonNull final String colormapKind;
+        final boolean useColormap;
+
+        FrameClass(boolean trueColor, @NonNull String colormapKind, boolean useColormap) {
+            this.trueColor = trueColor;
+            this.colormapKind = colormapKind;
+            this.useColormap = useColormap;
+        }
+    }
+
+    static FrameClass classifyShaderFileName(@Nullable String shaderFileName) {
+        String fn = shaderFileName != null ? shaderFileName : "";
+        boolean isTrueColor =
+                fn.contains("_truecolor_")
+                        || fn.contains("_geocolor_")
+                        || fn.contains("_firetemperature_")
+                        || fn.contains("_dust_")
+                        || fn.contains("_simplewatervapor_")
+                        || fn.contains("_ntmicro_")
+                        || fn.contains("_daycloudphase_")
+                        || fn.contains("_daylandcloudfire_")
+                        || fn.contains("_airmass_")
+                        || fn.contains("_sandwich_");
+
+        String colormapType = "none";
+        if (fn.contains("C13") || fn.contains("C14") || fn.contains("C15") || fn.contains("C16")) {
+            colormapType = "ir";
+        } else if (fn.contains("C08") || fn.contains("C09") || fn.contains("C10")) {
+            colormapType = "wv";
+        }
+
+        boolean useColormap = !isTrueColor && !"none".equals(colormapType);
+        return new FrameClass(isTrueColor, colormapType, useColormap);
+    }
+
+    public void clearSatellite() {
+        decodeGeneration.incrementAndGet();
+        fetchInFlight.clear();
+        satelliteLayer.clearAll();
+        triggerRepaint();
+    }
+
+    /**
+     * Full sync from JS: run key, optional style, target unix, and frame descriptors (small strings —
+     * no image bytes on the bridge).
+     */
+    public void syncFromJson(@Nullable String json) {
+        if (json == null || json.isEmpty()) return;
+        try {
+            JSONObject o = new JSONObject(json);
+            String runKey = o.optString("runKey", "");
+            if (!runKey.isEmpty() && !runKey.equals(lastRunKey)) {
+                lastRunKey = runKey;
+                decodeGeneration.incrementAndGet();
+                fetchInFlight.clear();
+                satelliteLayer.clearAll();
+            }
+
+            boolean visible = o.optBoolean("visible", true);
+            float opacity = (float) o.optDouble("opacity", 1.0);
+            int fillSmoothing = o.optInt("fillSmoothing", 0);
+            satelliteLayer.setVisible(visible);
+            satelliteLayer.setOpacity(opacity);
+            satelliteLayer.setFillSmoothing(fillSmoothing);
+
+            long targetUnix = Long.MIN_VALUE;
+            if (o.has("targetUnix") && !o.isNull("targetUnix")) {
+                targetUnix = o.getLong("targetUnix");
+            }
+            if (targetUnix != Long.MIN_VALUE) {
+                satelliteLayer.setActiveUnix(targetUnix);
+            }
+
+            String apiKey = o.optString("apiKey", "");
+            String bundleId = o.optString("bundleId", "");
+            JSONArray frames = o.optJSONArray("frames");
+            if (frames == null || apiKey.isEmpty()) {
+                triggerRepaint();
+                return;
+            }
+
+            final int gen = decodeGeneration.get();
+            for (int i = 0; i < frames.length(); i++) {
+                JSONObject f = frames.getJSONObject(i);
+                long unix = f.getLong("unix");
+                String url = f.getString("url");
+                String shaderFileName = f.optString("shaderFileName", "");
+                scheduleFetchIfNeeded(gen, unix, url, shaderFileName, apiKey, bundleId);
+            }
+            triggerRepaint();
+        } catch (Exception e) {
+            Log.e(TAG, "syncFromJson failed", e);
+        }
+    }
+
+    private void scheduleFetchIfNeeded(
+            int gen,
+            long unix,
+            @NonNull String url,
+            @NonNull String shaderFileName,
+            @NonNull String apiKey,
+            @NonNull String bundleId) {
+        if (satelliteLayer.isFrameCached(unix)) {
+            return;
+        }
+        if (!fetchInFlight.add(unix)) {
+            return;
+        }
+
+        satDecodeExecutor.execute(
+                () -> {
+                    try {
+                        if (gen != decodeGeneration.get()) {
+                            return;
+                        }
+                        Request.Builder reqBuilder =
+                                new Request.Builder().url(url).header("x-api-key", apiKey);
+                        if (bundleId != null && !bundleId.isEmpty()) {
+                            reqBuilder.header("x-app-identifier", bundleId);
+                        }
+                        Request req = reqBuilder.build();
+                        Call call = HTTP.newCall(req);
+                        try (Response resp = call.execute()) {
+                            if (!resp.isSuccessful() || resp.body() == null) {
+                                Log.w(
+                                        TAG,
+                                        "HTTP "
+                                                + (resp != null ? resp.code() : -1)
+                                                + " for unix="
+                                                + unix);
+                                mainHandler.post(() -> fetchInFlight.remove(unix));
+                                return;
+                            }
+                            ResponseBody body = resp.body();
+                            byte[] ktxBytes = body.bytes();
+                            if (gen != decodeGeneration.get()) {
+                                mainHandler.post(() -> fetchInFlight.remove(unix));
+                                return;
+                            }
+                            byte[] packed = SatelliteKtxDecoder.transcodeKtx2(ktxBytes);
+                            SatelliteKtxDecoder.Parsed parsed = SatelliteKtxDecoder.parsePacked(packed);
+                            if (parsed == null) {
+                                Log.w(TAG, "KTX2 transcode failed unix=" + unix);
+                                mainHandler.post(() -> fetchInFlight.remove(unix));
+                                return;
+                            }
+                            SatelliteMeshBuilder.MeshResult mesh =
+                                    SatelliteMeshBuilder.buildMesh(shaderFileName, parsed.width, parsed.height);
+                            FrameClass fc = classifyShaderFileName(shaderFileName);
+                            SatelliteLayer.PendingGpuUpload pending =
+                                    new SatelliteLayer.PendingGpuUpload(
+                                            unix,
+                                            mesh,
+                                            parsed,
+                                            fc.trueColor,
+                                            fc.colormapKind,
+                                            fc.useColormap);
+
+                            mainHandler.post(
+                                    () -> {
+                                        fetchInFlight.remove(unix);
+                                        if (gen != decodeGeneration.get()) {
+                                            return;
+                                        }
+                                        if (!isLayerAdded) {
+                                            findMapViewAndAddLayer();
+                                        }
+                                        satelliteLayer.queueGpuUpload(pending);
+                                        triggerRepaint();
+                                    });
+                        }
+                    } catch (IOException e) {
+                        Log.e(TAG, "fetch satellite frame unix=" + unix, e);
+                        mainHandler.post(() -> fetchInFlight.remove(unix));
+                    } catch (Exception e) {
+                        Log.e(TAG, "decode satellite frame unix=" + unix, e);
+                        mainHandler.post(() -> fetchInFlight.remove(unix));
+                    }
+                });
+    }
+
+    public void activateSatelliteCachedUnix(long unix) {
+        satelliteLayer.activateCachedUnix(unix);
+        triggerRepaint();
+    }
+
+    public void updateStyleFromJson(@Nullable String json) {
+        if (json == null || json.isEmpty()) return;
+        try {
+            JSONObject o = new JSONObject(json);
+            satelliteLayer.setVisible(o.optBoolean("visible", true));
+            satelliteLayer.setOpacity((float) o.optDouble("opacity", 1.0));
+            satelliteLayer.setFillSmoothing(o.optInt("fillSmoothing", 0));
+            triggerRepaint();
+        } catch (Exception e) {
+            Log.e(TAG, "updateStyleFromJson failed", e);
+        }
+    }
+}

package/lib/module/android/src/main/java/com/aguacerowx/reactnative/SatelliteMeshBuilder.java

@@ -0,0 +1,244 @@
+package com.aguacerowx.reactnative;
+
+import android.util.Log;
+
+import org.locationtech.proj4j.*;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * GEOS satellite mesh for Mapbox custom layer — parity with mapsgl {@code SatelliteShaderManager._createMeshGeometry}.
+ */
+public final class SatelliteMeshBuilder {
+
+    private static final Pattern PROJ_FROM_NAME =
+            Pattern.compile("_proj_([-\\d\\.eE]+)_([-\\d\\.eE]+)_([-\\d\\.eE]+)");
+
+    /** Default GOES-East CONUS mesh bounds in geos coordinates (meters). */
+    private static final double[] GOES_CONUS_EXTENT_M = {-3627020.7, 1583424.2, 1382521.8, 4588949.1};
+
+    private SatelliteMeshBuilder() {}
+
+    public static final class CustomProj {
+        final double h;
+        final double lon0;
+        final double xOff;
+        final double yOff;
+        final double xScale;
+        final double yScale;
+
+        CustomProj(double h, double lon0, double xOff, double yOff, double xScale, double yScale) {
+            this.h = h;
+            this.lon0 = lon0;
+            this.xOff = xOff;
+            this.yOff = yOff;
+            this.xScale = xScale;
+            this.yScale = yScale;
+        }
+    }
+
+    public static CustomProj parseProjectionFromFileName(String fileName) {
+        if (fileName == null) return null;
+        Matcher m = PROJ_FROM_NAME.matcher(fileName);
+        if (!m.find()) return null;
+        double scale = Double.parseDouble(m.group(3));
+        return new CustomProj(
+                35786023.0,
+                -75.0,
+                Double.parseDouble(m.group(1)),
+                Double.parseDouble(m.group(2)),
+                scale,
+                -scale);
+    }
+
+    public static final class MeshResult {
+        public final FloatBuffer vertexBuffer;
+        public final IntBuffer indexBuffer;
+        public final int indexCount;
+
+        MeshResult(FloatBuffer vertexBuffer, IntBuffer indexBuffer, int indexCount) {
+            this.vertexBuffer = vertexBuffer;
+            this.indexBuffer = indexBuffer;
+            this.indexCount = indexCount;
+        }
+    }
+
+    /**
+     * Web Mercator normalized [0,1] × [0,1] (same math as mapsgl {@code MercatorCoordinate.fromLngLat} x/y before tile scale).
+     */
+    private static double mercatorXFromLng(double lng) {
+        return (180.0 + lng) / 360.0;
+    }
+
+    private static double mercatorYFromLat(double lat) {
+        double clamped = Math.max(-85.05112878, Math.min(85.05112878, lat));
+        double sin = Math.sin(Math.toRadians(clamped));
+        return 0.5 - Math.log((1.0 + sin) / (1.0 - sin)) / (4.0 * Math.PI);
+    }
+
+    public static MeshResult buildMesh(String shaderFileName, int fullWidth, int fullHeight) {
+        String fn = shaderFileName != null ? shaderFileName : "";
+
+        int meshSubdivisions = 50;
+        String projString = "+proj=geos +h=35786023.0 +lon_0=-75.0 +sweep=x +no_defs";
+        double[] extent = new double[] {
+            GOES_CONUS_EXTENT_M[0], GOES_CONUS_EXTENT_M[1], GOES_CONUS_EXTENT_M[2], GOES_CONUS_EXTENT_M[3]
+        };
+
+        boolean isMesoscale = false;
+
+        if (fn.startsWith("F_") || fn.contains("MCMIPF") || fn.contains("CMIPF")) {
+            projString = "+proj=geos +h=35786023.0 +lon_0=-75.0 +sweep=x +no_defs";
+            extent = new double[] {-5434894.885056, -5434894.885056, 5434894.885056, 5434894.885056};
+            meshSubdivisions = 100;
+        } else if (fn.startsWith("M1_") || fn.startsWith("M2_") || fn.contains("MCMIPM") || fn.contains("CMIPM")) {
+            isMesoscale = true;
+            meshSubdivisions = 30;
+        }
+
+        CustomProj customProj = parseProjectionFromFileName(fn);
+        if (customProj != null) {
+            double h = customProj.h;
+            double xMinRad = customProj.xOff;
+            double xMaxRad = customProj.xOff + (fullWidth * customProj.xScale);
+            double yMinRad = customProj.yOff + (fullHeight * customProj.yScale);
+            double yMaxRad = customProj.yOff;
+            extent =
+                    new double[] {
+                        Math.min(xMinRad, xMaxRad) * h,
+                        Math.min(yMinRad, yMaxRad) * h,
+                        Math.max(xMinRad, xMaxRad) * h,
+                        Math.max(yMinRad, yMaxRad) * h
+                    };
+            projString =
+                    "+proj=geos +h="
+                            + h
+                            + " +lon_0="
+                            + customProj.lon0
+                            + " +sweep=x +no_defs";
+        } else if (isMesoscale) {
+            Log.w(
+                    "SatelliteMesh",
+                    "[SatelliteLayer] Mesoscale file name is missing _proj_xOff_yOff_scale: "
+                            + fn);
+        }
+
+        return createMeshGeometry(projString, extent, meshSubdivisions);
+    }
+
+    /**
+     * JS proj4 (mapsgl) accepts {@code +sweep=x|y} on {@code +proj=geos}; proj4j throws
+     * {@link org.locationtech.proj4j.UnsupportedParameterException}. Sweep selects ABI scan axis; omitting it uses
+     * proj4j's GEOS convention, which matches Aguacero GOES-East/West ABI meshes built with {@code +sweep=x} on web.
+     */
+    private static String projStringCompatibleWithProj4j(String proj) {
+        if (proj == null) {
+            return null;
+        }
+        return proj.replaceAll("\\s*\\+sweep=[^\\s]+", "");
+    }
+
+    private static MeshResult createMeshGeometry(String projectionString, double[] extent, int subdivisions) {
+        double xMin = extent[0];
+        double yMin = extent[1];
+        double xMax = extent[2];
+        double yMax = extent[3];
+
+        String projForJvm = projStringCompatibleWithProj4j(projectionString);
+
+        CRSFactory csFactory = new CRSFactory();
+        CoordinateReferenceSystem geo =
+                csFactory.createFromParameters("src", projForJvm);
+        CoordinateReferenceSystem wgs84 = csFactory.createFromName("EPSG:4326");
+        CoordinateTransform transform = new CoordinateTransformFactory().createTransform(geo, wgs84);
+
+        // Mapbox Maps Android custom layers (see {@link GridRenderLayer}) use mercator * 512 for a_pos, not 0..1.
+        final double tileSize = 512.0;
+
+        List<Float> vertices = new ArrayList<>();
+        List<Integer> indices = new ArrayList<>();
+
+        for (int row = 0; row <= subdivisions; row++) {
+            for (int col = 0; col <= subdivisions; col++) {
+                double u = col / (double) subdivisions;
+                double v = row / (double) subdivisions;
+
+                double projX = xMin + u * (xMax - xMin);
+                double projY = yMax - v * (yMax - yMin);
+
+                try {
+                    ProjCoordinate src = new ProjCoordinate(projX, projY);
+                    ProjCoordinate dst = new ProjCoordinate();
+                    transform.transform(src, dst);
+                    double lon = dst.x;
+                    double lat = dst.y;
+                    if (Math.abs(lon) > 180 || Math.abs(lat) > 90) {
+                        vertices.add(Float.NaN);
+                        vertices.add(Float.NaN);
+                        vertices.add(Float.NaN);
+                        vertices.add(Float.NaN);
+                    } else {
+                        float mx = (float) (mercatorXFromLng(lon) * tileSize);
+                        float my = (float) (mercatorYFromLat(lat) * tileSize);
+                        vertices.add(mx);
+                        vertices.add(my);
+                        vertices.add((float) u);
+                        vertices.add((float) v);
+                    }
+                } catch (Throwable t) {
+                    vertices.add(Float.NaN);
+                    vertices.add(Float.NaN);
+                    vertices.add(Float.NaN);
+                    vertices.add(Float.NaN);
+                }
+            }
+        }
+
+        int vertsPerRow = subdivisions + 1;
+        for (int row = 0; row < subdivisions; row++) {
+            for (int col = 0; col < subdivisions; col++) {
+                int i00 = row * vertsPerRow + col;
+                int i10 = i00 + 1;
+                int i01 = (row + 1) * vertsPerRow + col;
+                int i11 = i01 + 1;
+
+                int base = i00 * 4;
+                if (!Float.isNaN(vertices.get(base))
+                        && !Float.isNaN(vertices.get(i10 * 4))
+                        && !Float.isNaN(vertices.get(i01 * 4))
+                        && !Float.isNaN(vertices.get(i11 * 4))) {
+                    indices.add(i00);
+                    indices.add(i01);
+                    indices.add(i10);
+                    indices.add(i10);
+                    indices.add(i01);
+                    indices.add(i11);
+                }
+            }
+        }
+
+        float[] vertArr = new float[vertices.size()];
+        for (int i = 0; i < vertices.size(); i++) {
+            vertArr[i] = vertices.get(i);
+        }
+        int[] idxArr = new int[indices.size()];
+        for (int i = 0; i < indices.size(); i++) {
+            idxArr[i] = indices.get(i);
+        }
+
+        FloatBuffer vb = FloatBuffer.allocate(vertArr.length);
+        vb.put(vertArr);
+        vb.flip();
+
+        IntBuffer ib = IntBuffer.allocate(idxArr.length);
+        ib.put(idxArr);
+        ib.flip();
+
+        return new MeshResult(vb, ib, idxArr.length);
+    }
+}