@aguacerowx/react-native 0.0.4 → 0.0.7

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

@@ -0,0 +1,298 @@
+package com.aguacerowx.reactnative;
+
+import android.app.Activity;
+import android.util.Base64;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+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;
+
+// ADD THIS IMPORT
+import com.github.luben.zstd.Zstd;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.nio.ByteBuffer;
+
+public class GridRenderLayerView extends FrameLayout {
+
+    private final GridRenderLayer gridLayerImplementation;
+    private final String LAYER_ID = "weather-layer-" + getId();
+    private static final String TAG = "AguaceroWX";
+    private MapView mapView;
+    private boolean isLayerAdded = false;
+    private String belowLayerID = null;
+    private static byte[] lastDecompressedData = null;
+    private static int lastDataNx = 0;
+    private static int lastDataNy = 0;
+    private static float lastDataScale = 1.0f;
+    private static float lastDataOffset = 0.0f;
+    private static float lastDataMissing = 127.0f;
+    private static String lastDataScaleType = "linear";
+
+    public GridRenderLayerView(@NonNull ThemedReactContext context) {
+        super(context);
+        this.gridLayerImplementation = new GridRenderLayer(context);
+    }
+
+    public static String getLastDataScaleType() {
+        return lastDataScaleType;
+    }
+    
+    public void updateDataTexture(String dataFilePathOrBase64, int nx, int ny, float scale, float offset, float missing, String scaleType) {
+        if (dataFilePathOrBase64 == null) {
+            Log.e(TAG, "❌ [View] Data from manager is null!");
+            return;
+        }
+
+        if (!isLayerAdded) {
+            findMapViewAndAddLayer();
+        }
+
+        try {
+            byte[] compressedData;
+            if (dataFilePathOrBase64.startsWith("/")) {
+                File file = new File(dataFilePathOrBase64);
+                try (FileInputStream fis = new FileInputStream(file)) {
+                    compressedData = new byte[(int) file.length()];
+                    fis.read(compressedData);
+                }
+            } else {
+                compressedData = Base64.decode(dataFilePathOrBase64, Base64.DEFAULT);
+            }
+
+            int expectedLength = nx * ny;
+            byte[] decompressedDeltas = Zstd.decompress(compressedData, expectedLength);
+            byte[] reconstructedData = reconstructData(decompressedDeltas, expectedLength);
+            byte[] finalTextureBytes = transformData(reconstructedData);
+
+            // CACHE the decompressed, transformed data for the inspector
+            lastDecompressedData = finalTextureBytes;
+            lastDataNx = nx;
+            lastDataNy = ny;
+            lastDataScale = scale;
+            lastDataOffset = offset;
+            lastDataMissing = missing;
+            lastDataScaleType = scaleType; // FIX: Update the cached scaleType
+
+            gridLayerImplementation.updateDataTexture(finalTextureBytes, nx, ny, scale, offset, missing, scaleType);
+            triggerRepaint();
+
+        } catch (Exception e) {
+            Log.e(TAG, "❌❌❌ [View] CRITICAL ERROR during data processing: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    // Add a method to get the cached data
+    public static byte[] getLastDecompressedData() {
+        return lastDecompressedData;
+    }
+    
+    public static int getLastDataNx() {
+        return lastDataNx;
+    }
+    
+    public static int getLastDataNy() {
+        return lastDataNy;
+    }
+    
+    public static float getLastDataScale() {
+        return lastDataScale;
+    }
+    
+    public static float getLastDataOffset() {
+        return lastDataOffset;
+    }
+    
+    public static float getLastDataMissing() {
+        return lastDataMissing;
+    }
+
+    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);
+        // It's often more reliable to trigger map search here
+        findMapViewAndAddLayer();
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        super.onViewAdded(child);
+    }
+
+    private void findMapViewAndAddLayer() {
+        if (isLayerAdded) {
+            return;
+        }
+
+        Activity activity = ((ThemedReactContext) getContext()).getCurrentActivity();
+        if (activity == null) {
+            Log.e(TAG, "❌ [View] Could not find current Activity to search for MapView.");
+            return;
+        }
+
+        View rootView = activity.findViewById(android.R.id.content);
+        if (rootView == null) {
+            Log.e(TAG, "❌ [View] Could not find root view of the Activity.");
+            return;
+        }
+
+        MapView foundMap = findMapViewRecursive(rootView);
+
+        if (foundMap != null) {
+            this.mapView = foundMap;
+            final MapboxMap mapboxMap = mapView.getMapboxMap();
+
+            Style.OnStyleLoaded styleLoadedCallback = style -> {
+                if (!isLayerAdded && !style.styleLayerExists(LAYER_ID)) {
+                    LayerPosition position = null;
+                    if (this.belowLayerID != null && !this.belowLayerID.isEmpty()) {
+                        if (style.styleLayerExists(this.belowLayerID)) {
+                            position = new LayerPosition(null, this.belowLayerID, null);
+                        } else {
+                            Log.w(TAG, "⚠️ [View] Target layer '" + this.belowLayerID + "' NOT FOUND. Adding layer on top as a fallback.");
+                        }
+                    }
+                    style.addStyleCustomLayer(LAYER_ID, gridLayerImplementation, position);
+                    isLayerAdded = true;
+                    triggerRepaint();
+                }
+            };
+
+            Style currentStyle = mapboxMap.getStyle();
+            if (currentStyle != null && currentStyle.isStyleLoaded()) {
+                styleLoadedCallback.onStyleLoaded(currentStyle);
+            } else {
+                mapboxMap.getStyle(styleLoadedCallback);
+            }
+
+        } else {
+            Log.e(TAG, "❌❌❌ [View] FAILED to find MapView after searching from the root view! ❌❌❌");
+        }
+    }
+
+    private MapView findMapViewRecursive(View view) {
+        if (view instanceof MapView) {
+            return (MapView) view;
+        }
+        if (view instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup) view;
+            for (int i = 0; i < viewGroup.getChildCount(); i++) {
+                MapView found = findMapViewRecursive(viewGroup.getChildAt(i));
+                if (found != null) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+
+    private void triggerRepaint() {
+        if (mapView != null) {
+            mapView.post(mapView.getMapboxMap()::triggerRepaint);
+        }
+    }
+
+    public void setOpacity(float opacity) {
+        gridLayerImplementation.setOpacity(opacity);
+        triggerRepaint();
+    }
+
+    public void setSmoothing(boolean enabled) {
+        gridLayerImplementation.setSmoothing(enabled);
+        triggerRepaint();
+    }
+
+    public void setDataRange(float[] range) {
+        gridLayerImplementation.setDataRange(range);
+        triggerRepaint();
+    }
+
+    public void setConversionType(int conversionType) {
+        gridLayerImplementation.setConversionType(conversionType);
+        triggerRepaint();
+    }
+
+    public void updateColormapTexture(String colormapAsBase64) {
+        if (colormapAsBase64 == null) {
+            return;
+        }
+        if (!isLayerAdded) {
+            findMapViewAndAddLayer();
+        }
+
+        byte[] bytes = Base64.decode(colormapAsBase64, Base64.DEFAULT);
+        ByteBuffer colormapBuffer = ByteBuffer.allocateDirect(bytes.length);
+        colormapBuffer.put(bytes);
+        colormapBuffer.position(0);
+        gridLayerImplementation.updateColormapTexture(colormapBuffer);
+        triggerRepaint();
+    }
+
+    public void updateGeometry(ReadableMap corners, ReadableMap gridDef) {
+        if (!isLayerAdded) {
+            findMapViewAndAddLayer();
+        }
+        gridLayerImplementation.updateGeometry(corners, gridDef);
+        triggerRepaint();
+    }
+
+    /**
+     * Reconstructs the full data array from the delta-encoded values.
+     * @param decompressedDeltas The array of deltas.
+     * @param expectedLength The total size of the final grid.
+     * @return The fully reconstructed data array.
+     */
+    private byte[] reconstructData(byte[] decompressedDeltas, int expectedLength) {
+        byte[] reconstructedData = new byte[expectedLength];
+        if (decompressedDeltas.length > 0 && expectedLength > 0) {
+            reconstructedData[0] = decompressedDeltas[0];
+            for (int i = 1; i < expectedLength; i++) {
+                reconstructedData[i] = (byte) (reconstructedData[i - 1] + decompressedDeltas[i]);
+            }
+        }
+        return reconstructedData;
+    }
+
+    /**
+     * Transforms the signed byte data (-128 to 127) to unsigned byte data (0 to 255)
+     * suitable for an ALPHA texture.
+     * @param finalData The reconstructed data array.
+     * @return The transformed data array ready for the GPU.
+     */
+    private byte[] transformData(byte[] finalData) {
+        byte[] transformedData = new byte[finalData.length];
+        for (int i = 0; i < finalData.length; i++) {
+            transformedData[i] = (byte) (finalData[i] + 128);
+        }
+        return transformedData;
+    }
+
+    // Add this method to GridRenderLayerView.java
+    public void updateDataParameters(float scale, float offset, float missing) {
+        // Update the cached values for the inspector
+        lastDataScale = scale;
+        lastDataOffset = offset;
+        lastDataMissing = missing;
+    }
+
+    public void clearData() {
+        gridLayerImplementation.clearData();
+        triggerRepaint();
+    }
+}

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

@@ -0,0 +1,118 @@
+package com.aguacerowx.reactnative;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import android.util.Log;
+
+import java.util.Map;
+import java.util.HashMap;
+
+public class GridRenderManager extends SimpleViewManager<GridRenderLayerView> {
+
+    private static final String REACT_CLASS = "GridRenderLayer";
+    private static final int COMMAND_UPDATE_DATA_TEXTURE = 1;
+    private static final int COMMAND_UPDATE_COLORMAP_TEXTURE = 2;
+    private static final int COMMAND_UPDATE_GEOMETRY = 3;
+    private static final int COMMAND_UPDATE_DATA_PARAMETERS = 4;
+    private static final int COMMAND_CLEAR = 5;
+
+    @NonNull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @NonNull
+    @Override
+    protected GridRenderLayerView createViewInstance(@NonNull ThemedReactContext reactContext) {
+        return new GridRenderLayerView(reactContext);
+    }
+
+    @ReactProp(name = "opacity", defaultFloat = 1.0f)
+    public void setOpacity(GridRenderLayerView view, float opacity) {
+        view.setOpacity(opacity);
+    }
+
+    @ReactProp(name = "dataRange")
+    public void setDataRange(GridRenderLayerView view, @Nullable ReadableArray dataRange) {
+        if (dataRange != null && dataRange.size() == 2) {
+            float[] range = new float[]{
+                (float) dataRange.getDouble(0),
+                (float) dataRange.getDouble(1)
+            };
+            view.setDataRange(range);
+        }
+    }
+
+    @ReactProp(name = "belowID")
+    public void setBelowID(GridRenderLayerView view, @Nullable String belowID) {
+        view.setBelowID(belowID);
+    }
+
+    @ReactProp(name = "smoothing", defaultBoolean = true)
+    public void setSmoothing(GridRenderLayerView view, boolean enabled) {
+        view.setSmoothing(enabled);
+    }
+
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        Map<String, Integer> commands = new HashMap<>();
+        commands.put("updateDataTexture", COMMAND_UPDATE_DATA_TEXTURE);
+        commands.put("updateColormapTexture", COMMAND_UPDATE_COLORMAP_TEXTURE);
+        commands.put("updateGeometry", COMMAND_UPDATE_GEOMETRY);
+        commands.put("updateDataParameters", COMMAND_UPDATE_DATA_PARAMETERS);
+        commands.put("clear", COMMAND_CLEAR);
+        return commands;
+    }
+
+    @Override
+    public void receiveCommand(@NonNull GridRenderLayerView view, int commandId, @Nullable ReadableArray args) {
+        switch (commandId) {
+            case COMMAND_UPDATE_DATA_TEXTURE:    
+                String data = args.getString(0);
+                int nx = args.getInt(1);
+                int ny = args.getInt(2);
+                float scale = (float) args.getDouble(3);
+                float offset = (float) args.getDouble(4);
+                float missing = (float) args.getDouble(5);
+                String scaleType = args.getString(6);
+
+                view.updateDataTexture(data, nx, ny, scale, offset, missing, scaleType);
+                break;
+
+            case COMMAND_UPDATE_COLORMAP_TEXTURE:
+                if (args != null && args.size() > 0) {
+                    String colormapBase64 = args.getString(0);
+                    view.updateColormapTexture(colormapBase64);
+                }
+                break;
+
+            case COMMAND_UPDATE_GEOMETRY:
+                if (args != null && args.size() >= 2) {
+                    ReadableMap corners = args.getMap(0);
+                    ReadableMap gridDef = args.getMap(1);
+                    view.updateGeometry(corners, gridDef);
+                }
+                break;
+
+            case COMMAND_UPDATE_DATA_PARAMETERS:
+                if (args != null && args.size() >= 3) {
+                    float scaleParam = (float) args.getDouble(0);
+                    float offsetParam = (float) args.getDouble(1);
+                    float missingParam = (float) args.getDouble(2);
+                    view.updateDataParameters(scaleParam, offsetParam, missingParam);
+                }
+                break;
+
+            case COMMAND_CLEAR:
+                view.clearData();
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+package com.aguacerowx.reactnative;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+
+public class InspectorModule extends ReactContextBaseJavaModule {
+    
+    public InspectorModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "InspectorModule";
+    }
+
+    @ReactMethod
+    public void getValueAtGridIndex(int i, int j, Promise promise) {
+        try {
+            byte[] data = GridRenderLayerView.getLastDecompressedData();
+            if (data == null) {
+                promise.resolve(null);
+                return;
+            }
+            
+            int nx = GridRenderLayerView.getLastDataNx();
+            int ny = GridRenderLayerView.getLastDataNy();
+            float scale = GridRenderLayerView.getLastDataScale();
+            float offset = GridRenderLayerView.getLastDataOffset();
+            float missing = GridRenderLayerView.getLastDataMissing();
+            
+            // Calculate index
+            int index = j * nx + i;
+            
+            // Bounds check
+            if (index < 0 || index >= data.length) {
+                promise.resolve(null);
+                return;
+            }
+            
+            // Read byte value
+            int byteValue = data[index] & 0xFF; // Convert to unsigned
+            int signedQuantizedValue = byteValue - 128;
+            int missingQuantized = Math.round(missing - 128);
+            
+            // Check for missing value
+            if (signedQuantizedValue == missingQuantized) {
+                promise.resolve(null);
+                return;
+            }
+            
+            // Calculate actual value
+            double value = signedQuantizedValue * scale + offset;
+            
+            promise.resolve(value);
+        } catch (Exception e) {
+            promise.reject("ERROR", e.getMessage());
+        }
+    }
+}

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

@@ -0,0 +1,107 @@
+package com.aguacerowx.reactnative;
+
+import android.content.Context;
+import android.opengl.GLES20;
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+/**
+ * Utility class for loading, compiling, and linking OpenGL ES 2.0 shaders.
+ */
+public class ShaderUtils {
+
+    public static final String TAG = "ShaderUtils";
+
+    /**
+     * Reads a raw text file from the res/raw directory.
+     *
+     * @param context    The application context.
+     * @param resourceId The resource ID (e.g., R.raw.vertex_shader).
+     * @return The content of the file as a String.
+     */
+    public static String readRawTextFile(Context context, int resourceId) {
+        InputStream inputStream = context.getResources().openRawResource(resourceId);
+        InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
+        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
+        String nextLine;
+        StringBuilder body = new StringBuilder();
+        try {
+            while ((nextLine = bufferedReader.readLine()) != null) {
+                body.append(nextLine);
+                body.append('\n');
+            }
+        } catch (IOException e) {
+            return null;
+        }
+        return body.toString();
+    }
+
+    /**
+     * Compiles a shader from source code.
+     *
+     * @param type       The shader type (GLES20.GL_VERTEX_SHADER or GLES20.GL_FRAGMENT_SHADER).
+     * @param shaderCode The GLSL source code.
+     * @return The handle to the compiled shader.
+     */
+    private static int compileShader(int type, String shaderCode) {
+        final int shader = GLES20.glCreateShader(type);
+        if (shader == 0) {
+            Log.e(TAG, "glCreateShader failed for type " + type);
+            return 0;
+        }
+        GLES20.glShaderSource(shader, shaderCode);
+        GLES20.glCompileShader(shader);
+
+        final int[] compileStatus = new int[1];
+        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
+        if (compileStatus[0] == 0) {
+            Log.e(TAG, "Shader compilation failed: " + GLES20.glGetShaderInfoLog(shader));
+            GLES20.glDeleteShader(shader);
+            return 0;
+        }
+        return shader;
+    }
+
+    /**
+     * Links a vertex and fragment shader into a complete OpenGL program.
+     *
+     * @param vertexShaderCode   The vertex shader source code.
+     * @param fragmentShaderCode The fragment shader source code.
+     * @return The handle to the linked program.
+     */
+    public static int createProgram(String vertexShaderCode, String fragmentShaderCode) {
+        int vertexShader = compileShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
+        int fragmentShader = compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);
+
+        if (vertexShader == 0 || fragmentShader == 0) {
+            return 0;
+        }
+
+        final int program = GLES20.glCreateProgram();
+        if (program == 0) {
+            Log.e(TAG, "glCreateProgram failed");
+            return 0;
+        }
+        GLES20.glAttachShader(program, vertexShader);
+        GLES20.glAttachShader(program, fragmentShader);
+        GLES20.glLinkProgram(program);
+
+        final int[] linkStatus = new int[1];
+        GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
+        if (linkStatus[0] == 0) {
+            Log.e(TAG, "Program linking failed: " + GLES20.glGetProgramInfoLog(program));
+            GLES20.glDeleteProgram(program);
+            return 0;
+        }
+
+        // Shaders are no longer needed after linking
+        GLES20.glDeleteShader(vertexShader);
+        GLES20.glDeleteShader(fragmentShader);
+
+        return program;
+    }
+}