@aguacerowx/react-native 0.0.4 → 0.0.6

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

@@ -0,0 +1,166 @@
+// packages/com/aguacerowx/reactnative/WeatherFrameProcessorModule.java
+
+package com.aguacerowx.reactnative;
+
+import androidx.annotation.NonNull;
+import android.util.Base64;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.network.OkHttpClientProvider; 
+import android.util.Log;
+
+import org.json.JSONObject;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+
+
+public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
+
+    private final ExecutorService executorService;
+    private volatile int currentRunToken = 0;
+    private final ReactApplicationContext reactContext;
+
+    WeatherFrameProcessorModule(ReactApplicationContext context) {
+        super(context);
+        this.reactContext = context;
+        
+        int coreCount = Runtime.getRuntime().availableProcessors();
+        int optimalWorkerCount = Math.max(4, Math.min(coreCount - 1, 8));
+
+        this.executorService = Executors.newFixedThreadPool(optimalWorkerCount);
+        android.util.Log.d("AguaceroWX", "Initialized with " + optimalWorkerCount + " workers (" + coreCount + " cores available)");
+    }
+
+    @ReactMethod
+    public void cancelAllFrames() {
+        currentRunToken++;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "WeatherFrameProcessorModule";
+    }
+
+    @ReactMethod
+    public void processFrame(ReadableMap options, Callback callback) {
+        final int taskToken = this.currentRunToken;
+        executorService.execute(() -> {
+            FileOutputStream fos = null;
+            try {
+                if (taskToken != this.currentRunToken) {
+                    return; // Task was cancelled
+                }
+
+                // --- START OF REPLACEMENT ---
+
+                // 1. Get the shared OkHttpClient instance from React Native
+                OkHttpClient client = OkHttpClientProvider.getOkHttpClient();
+
+                // 2. Get request details from options
+                String urlString = options.getString("url");
+                String apiKey = options.getString("apiKey");
+                String bundleId = options.getString("bundleId");
+
+                // 3. Build the OkHttp Request
+                Request.Builder requestBuilder = new Request.Builder()
+                        .url(urlString)
+                        .header("x-api-key", apiKey);
+
+                if (bundleId != null) {
+                    requestBuilder.header("x-app-identifier", bundleId);
+                }
+                
+                Request request = requestBuilder.build();
+
+                String responseString;
+                // 4. Execute the request and handle the response
+                try (Response response = client.newCall(request).execute()) {
+                    if (!response.isSuccessful()) {
+                        throw new IOException("HTTP Error: " + response.code());
+                    }
+                    
+                    ResponseBody body = response.body();
+                    if (body == null) {
+                        throw new IOException("Response body was null");
+                    }
+                    responseString = body.string();
+                }
+
+                // --- END OF REPLACEMENT ---
+
+                // The rest of your logic remains the same
+                JSONObject jsonResponse = new JSONObject(responseString);
+                if (!jsonResponse.has("data") || !jsonResponse.has("encoding")) {
+                    // If the core keys are missing, the response is invalid. Log it and fail.
+                    throw new IOException("Invalid API response. 'data' or 'encoding' key is missing. Response: " + responseString);
+                }
+
+                String b64CompressedData = jsonResponse.getString("data");
+                JSONObject encoding = jsonResponse.getJSONObject("encoding");
+
+
+                if (!encoding.has("scale") || !encoding.has("offset") || !encoding.has("missing_quantized")) {
+                    // If the encoding object is missing required values, fail with a clear error.
+                    throw new IOException("Invalid 'encoding' object in API response. Required keys are missing. Response: " + responseString);
+                }
+
+                byte[] compressedData = Base64.decode(b64CompressedData, Base64.DEFAULT);
+
+                File cacheDir = reactContext.getCacheDir();
+                String fileName = "frame_" + urlString.hashCode() + ".zst";
+                File dataFile = new File(cacheDir, fileName);
+                
+                fos = new FileOutputStream(dataFile);
+                fos.write(compressedData);
+                fos.flush();
+                fos.close();
+                fos = null;
+
+                WritableMap responseMap = Arguments.createMap();
+                responseMap.putString("filePath", dataFile.getAbsolutePath());
+                responseMap.putDouble("scale", encoding.getDouble("scale"));
+                responseMap.putDouble("offset", encoding.getDouble("offset"));
+                responseMap.putDouble("missing", encoding.getDouble("missing_quantized"));
+                if (encoding.has("scale_type")) {
+                    responseMap.putString("scaleType", encoding.getString("scale_type"));
+                }
+                responseMap.putString("dataAsBase64", b64CompressedData);
+
+                callback.invoke(null, responseMap);
+
+            } catch (Exception e) {
+                if (taskToken == this.currentRunToken) {
+                    android.util.Log.e("AguaceroWX", "Error processing frame", e);
+                    callback.invoke(e.getMessage(), null);
+                }
+            } finally {
+                if (fos != null) {
+                    try {
+                        fos.close();
+                    } catch (IOException e) {
+                        android.util.Log.e("AguaceroWX", "Error closing file stream", e);
+                    }
+                }
+            }
+        });
+    }
+}

package/lib/module/android/src/main/res/raw/debug_fragment_shader.glsl

@@ -0,0 +1,13 @@
+precision highp float;
+
+varying vec2 v_texCoord;
+uniform sampler2D u_data_texture;
+
+void main() {
+  // Read the raw normalized value [0.0, 1.0] from the texture's alpha channel.
+  float raw_normalized_value = texture2D(u_data_texture, v_texCoord).a;
+
+  // Output this value directly as a grayscale color.
+  // If the data is valid, this will produce a black and white weather map.
+  gl_FragColor = vec4(raw_normalized_value, raw_normalized_value, raw_normalized_value, 1.0);
+}

package/lib/module/android/src/main/res/raw/debug_vertex_shader.glsl

@@ -0,0 +1,13 @@
+attribute vec2 a_position; // Vertex position in Mercator coordinates (0.0 to 1.0)
+attribute vec2 a_texCoord;
+
+varying vec2 v_texCoord;
+
+void main() {
+  // This is a "passthrough" shader. It IGNORES the u_matrix from the map camera.
+  // It converts the input position (0..1) directly to OpenGL clip space (-1..1).
+  // This should paint a giant square over the entire screen, regardless of map pan/zoom.
+  gl_Position = vec4(a_position.x * 2.0 - 1.0, (1.0 - a_position.y) * 2.0 - 1.0, 0.0, 1.0);
+  
+  v_texCoord = a_texCoord;
+}

package/lib/module/android/src/main/res/raw/fragment_shader.glsl

@@ -0,0 +1,98 @@
+// packages/react-native/android/src/main/res/raw/fragment_shader.glsl
+
+precision highp float;
+varying vec2 v_texCoord;
+
+uniform sampler2D u_data_texture;
+uniform sampler2D u_colormap_texture;
+uniform float u_scale;
+uniform float u_offset;
+uniform float u_missing_quantized;
+uniform float u_opacity;
+uniform vec2 u_data_range;
+uniform vec2 u_texture_size;
+uniform int u_smoothing;
+
+// --- START OF FIX: Add the new uniform ---
+uniform int u_scale_type; // 0 for linear, 1 for sqrt
+// --- END OF FIX ---
+
+// Custom bilinear filtering that respects NaN boundaries
+float sampleDataTextureSmooth(vec2 uv) {
+    float missing_in_texture_range = u_missing_quantized + 128.0;
+
+    // Get the four corner samples for bilinear interpolation
+    vec2 pixel_coord = uv * u_texture_size;
+    vec2 pixel_floor = floor(pixel_coord - 0.5) + 0.5;
+    vec2 f = pixel_coord - pixel_floor;
+
+    // Sample the 2x2 grid
+    float s00 = texture2D(u_data_texture, (pixel_floor + vec2(0.0, 0.0)) / u_texture_size).a * 255.0;
+    float s10 = texture2D(u_data_texture, (pixel_floor + vec2(1.0, 0.0)) / u_texture_size).a * 255.0;
+    float s01 = texture2D(u_data_texture, (pixel_floor + vec2(0.0, 1.0)) / u_texture_size).a * 255.0;
+    float s11 = texture2D(u_data_texture, (pixel_floor + vec2(1.0, 1.0)) / u_texture_size).a * 255.0;
+
+    // Check which samples are valid (not NaN)
+    bool valid00 = abs(s00 - missing_in_texture_range) >= 0.5;
+    bool valid10 = abs(s10 - missing_in_texture_range) >= 0.5;
+    bool valid01 = abs(s01 - missing_in_texture_range) >= 0.5;
+    bool valid11 = abs(s11 - missing_in_texture_range) >= 0.5;
+
+    // If ANY sample is NaN, return NaN (this pixel is on an edge)
+    if (!valid00 || !valid10 || !valid01 || !valid11) {
+        return missing_in_texture_range;
+    }
+
+    // All samples are valid - do proper bilinear interpolation
+    float s0 = mix(s00, s10, f.x);
+    float s1 = mix(s01, s11, f.x);
+    return mix(s0, s1, f.y);
+}
+
+// Simple nearest-neighbor sampling
+float sampleDataTextureNearest(vec2 uv) {
+    // Snap to exact pixel center
+    vec2 snapped_coord = floor(uv * u_texture_size + 0.5) / u_texture_size;
+    return texture2D(u_data_texture, snapped_coord).a * 255.0;
+}
+
+void main() {
+    // Choose sampling method based on smoothing setting
+    float value_in_texture;
+    if (u_smoothing == 1) {
+        value_in_texture = sampleDataTextureSmooth(v_texCoord);
+    } else {
+        value_in_texture = sampleDataTextureNearest(v_texCoord);
+    }
+
+    float missing_in_texture_range = u_missing_quantized + 128.0;
+
+    // Check if this pixel is a predefined missing value
+    if (abs(value_in_texture - missing_in_texture_range) < 0.5) {
+        discard;
+    }
+
+    // Step 1: Standard linear dequantization
+    float quantized_value = value_in_texture - 128.0;
+    float intermediate_value = quantized_value * u_scale + u_offset;
+    float raw_value = intermediate_value; // Default to linear
+
+    // Step 2: Apply non-linear inverse scaling if specified
+    if (u_scale_type == 1) { // 1 represents 'sqrt'
+        // Square the intermediate value while preserving its sign
+        raw_value = intermediate_value * abs(intermediate_value);
+    }
+
+    // If the data is below the specified minimum range, make it invisible.
+    if (raw_value < u_data_range.x) {
+        discard;
+    }
+
+    // Normalize the value to a 0-1 coordinate for colormap lookup
+    float colormap_coord = (raw_value - u_data_range.x) / (u_data_range.y - u_data_range.x);
+    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
+
+    // Sample the colormap and apply opacity
+    vec4 color = texture2D(u_colormap_texture, vec2(colormap_coord, 0.5));
+    gl_FragColor = vec4(color.rgb, color.a * u_opacity);
+}

package/lib/module/android/src/main/res/raw/vertex_shader.glsl

@@ -0,0 +1,20 @@
+// The view-projection matrix from the Mapbox camera
+uniform mat4 u_matrix;
+
+// Attributes passed from the vertex buffer
+attribute vec2 a_position; // Vertex position in Mercator coordinates (0.0 to 1.0)
+attribute vec2 a_texCoord; // Texture coordinate (0.0 to 1.0)
+
+// Passed to the fragment shader
+varying vec2 v_texCoord;
+
+void main() {
+  // This is the intended use.
+  // The u_matrix correctly transforms the 2D Mercator coordinate (a_position)
+  // into the final 4D clip space position for the GPU.
+  // We construct a vec4 with z=0.0 and w=1.0 to treat it as a point on the map's surface.
+  gl_Position = u_matrix * vec4(a_position, 0.0, 1.0);
+
+  // Pass the texture coordinate to the fragment shader
+  v_texCoord = a_texCoord;
+}

package/lib/module/babel.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+  ignore: [/node_modules/]
+};
+//# sourceMappingURL=babel.config.js.map

package/lib/module/babel.config.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["module","exports","presets","ignore"],"sourceRoot":"..\\..","sources":["babel.config.js"],"mappings":"AAAAA,MAAM,CAACC,OAAO,GAAG;EACfC,OAAO,EAAE,CAAC,wCAAwC,CAAC;EACnDC,MAAM,EAAE,CAAC,cAAc;AACzB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,3 @@
+export { MapManager } from './src/MapManager';
+export { WeatherLayerManager } from './src/WeatherLayerManager';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MapManager","WeatherLayerManager"],"sourceRoot":"..\\..","sources":["index.js"],"mappings":"AAAA,SAASA,UAAU,QAAQ,kBAAkB;AAC7C,SAASC,mBAAmB,QAAQ,2BAA2B","ignoreList":[]}

package/lib/module/lib/commonjs/README.md

@@ -0,0 +1,61 @@
+# @aguacerowx/react-native
+
+Welcome to the official React Native SDK for AguaceroWX.
+
+## Installation
+```bash
+npm install @aguacerowx/react-native
+```
+
+### Important Prerequisite: Mapbox SDK v11
+
+This library is built on top of `@rnmapbox/maps` and requires the Mapbox Maps SDK v11 for both iOS and Android. You must perform the following manual setup steps to configure your project correctly.
+
+## iOS Setup
+
+You must explicitly enable Mapbox SDK v11 in your iOS project.
+
+### Modify your Podfile
+
+Open your project's `ios/Podfile` and add the following lines near the top of the file. This tells the `@rnmapbox/maps` library to use a v11 version of the native SDK.
+```ruby
+# Add these lines near the top of your ios/Podfile
+require_relative '../node_modules/@rnmapbox/maps/scripts/mapbox-rb'
+$RNMapboxMapsVersion = '~> 11.0' # This enforces Mapbox SDK v11
+use_mapbox_maps!
+```
+
+### Install Pods
+
+After saving the Podfile, navigate to your `ios` directory in the terminal and run a fresh pod installation.
+```bash
+cd ios
+pod install
+```
+
+## Android Setup
+
+Android requires configuration for Mapbox credentials and an additional native dependency.
+
+### Configure Mapbox Credentials
+
+You will need a secret token with `DOWNLOADS:READ` scope and a public token.
+
+In your `android/gradle.properties` file, add your secret token:
+```properties
+# android/gradle.properties
+MAPBOX_DOWNLOADS_TOKEN=sk.xxxxxxxxxx
+```
+
+In your `android/app/build.gradle` file, add your public token inside the `defaultConfig` block:
+```groovy
+// android/app/build.gradle
+android {
+    defaultConfig {
+        // ... other configs
+        buildConfigField "String", "MAPBOX_ACCESS_TOKEN", "\"pk.xxxxxxxxxx\""
+    }
+}
+```
+
+After completing these steps, your application should be correctly configured to use the library. For more detailed information or troubleshooting, please refer to the official `@rnmapbox/maps` documentation.

package/lib/module/lib/commonjs/android/build.gradle

@@ -0,0 +1,85 @@
+// @aguacerowx/react-native/android/build.gradle
+
+// This block is correct and necessary.
+repositories {
+    google()
+    mavenCentral()
+    maven {
+        url 'https://api.mapbox.com/downloads/v2/releases/maven'
+        authentication {
+            basic(BasicAuthentication)
+        }
+        credentials {
+            // It's good practice to check for the property on the root project
+            username = "mapbox"
+            password = project.rootProject.findProperty("MAPBOX_DOWNLOADS_TOKEN") ?: System.getenv("MAPBOX_DOWNLOADS_TOKEN")
+        }
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace 'com.aguacerowx.reactnative'
+    compileSdk 34 // Consider using rootProject.ext.compileSdkVersion for consistency
+
+    defaultConfig {
+        minSdk 23 // Consider using rootProject.ext.minSdkVersion
+        targetSdk 34
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+// These dependencies can be declared immediately.
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    api 'org.locationtech.proj4j:proj4j:1.1.5'
+    implementation 'com.github.luben:zstd-jni:1.5.7-6@aar'
+}
+
+
+// --- THIS IS THE ENHANCED, SELF-CONFIGURING BLOCK ---
+// This block delays dependency resolution until the whole project is configured.
+// It detects the environment and chooses the correct Mapbox artifact automatically.
+project.afterEvaluate {
+    // 1. Resolve the Mapbox Version (your existing logic)
+    def resolvedMapboxVersion
+    if (project.rootProject.hasProperty('mapboxMapsVersion')) {
+        resolvedMapboxVersion = project.rootProject.mapboxMapsVersion
+        println "[aguacerowx] Found mapboxMapsVersion: ${resolvedMapboxVersion}"
+    } else {
+        resolvedMapboxVersion = "11.15.2" // A known-good fallback
+        println "[aguacerowx] WARNING: Could not find 'mapboxMapsVersion' property. Falling back to ${resolvedMapboxVersion}."
+    }
+
+    // 2. Detect if @rnmapbox/maps is present in the user's project
+    // We check the root project to see all included modules.
+    def rnMapboxIsPresent = project.rootProject.findProject(':rnmapbox_maps') != null
+    def mapboxArtifact
+
+    // 3. Choose the correct Mapbox artifact based on the detection
+    if (rnMapboxIsPresent) {
+        // If @rnmapbox/maps is present, we MUST use the ndk27 variant to avoid conflicts.
+        mapboxArtifact = "android-ndk27"
+        println "[aguacerowx] @rnmapbox/maps detected. Using Mapbox artifact: '${mapboxArtifact}' to ensure compatibility."
+    } else {
+        // If it's not present, use the standard 'android' variant.
+        mapboxArtifact = "android"
+        println "[aguacerowx] @rnmapbox/maps not detected. Using standard Mapbox artifact: '${mapboxArtifact}'."
+    }
+
+    // 4. Add the chosen Mapbox dependency using the version and artifact we just determined.
+    dependencies {
+        implementation "com.mapbox.maps:${mapboxArtifact}:${resolvedMapboxVersion}"
+    }
+}

package/lib/module/lib/commonjs/android/src/main/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.aguacerowx.reactnative">
+    <!-- This manifest is for a library module. It requires very little. -->
+    <!-- The package name MUST exactly match the namespace in build.gradle -->
+    <!-- and the package declarations in your Java files. -->
+</manifest>

package/lib/module/lib/commonjs/babel.config.js

@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+  ignore: [/node_modules/]
+};
+//# sourceMappingURL=babel.config.js.map

package/lib/module/lib/commonjs/babel.config.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["module","exports","presets","ignore"],"sourceRoot":"..\\..","sources":["babel.config.js"],"mappings":";;AAAAA,MAAM,CAACC,OAAO,GAAG;EACfC,OAAO,EAAE,CAAC,wCAAwC,CAAC;EACnDC,MAAM,EAAE,CAAC,cAAc;AACzB,CAAC","ignoreList":[]}

package/lib/module/lib/commonjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "MapManager", {
+  enumerable: true,
+  get: function () {
+    return _MapManager.MapManager;
+  }
+});
+Object.defineProperty(exports, "WeatherLayerManager", {
+  enumerable: true,
+  get: function () {
+    return _WeatherLayerManager.WeatherLayerManager;
+  }
+});
+var _MapManager = require("./src/MapManager");
+var _WeatherLayerManager = require("./src/WeatherLayerManager");
+//# sourceMappingURL=index.js.map

package/lib/module/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_MapManager","require","_WeatherLayerManager"],"sourceRoot":"..\\..","sources":["index.js"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AACA,IAAAC,oBAAA,GAAAD,OAAA","ignoreList":[]}