@aguacerowx/react-native 0.0.42 → 0.0.44

package/android/build.gradle

@@ -40,6 +40,21 @@ android {
     defaultConfig {
         minSdk 23 
         targetSdk 34
+        ndk {
+            abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+        }
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared"
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "src/main/cpp/CMakeLists.txt"
+            version "3.22.1"
+        }
     }
 
     buildTypes {
@@ -71,6 +86,7 @@ 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'
+    implementation 'com.squareup.okhttp3:okhttp:4.12.0'
 }
 
 project.afterEvaluate {

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,43 @@
+# Minimal Basis Universal KTX2 transcoder JNI for GOES satellite tiles (parity with mapsgl satelliteKtxWorker.js).
+cmake_minimum_required(VERSION 3.22)
+project(aguacero_satellite_ktx)
+
+set(CMAKE_CXX_STANDARD 17)
+
+include(FetchContent)
+FetchContent_Declare(
+        basis_universal
+        GIT_REPOSITORY https://github.com/BinomialLLC/basis_universal.git
+        GIT_TAG master
+        GIT_SHALLOW TRUE
+)
+# Do NOT use FetchContent_MakeAvailable: upstream CMake always builds the `basisu` CLI and links
+# `-lpthread`, which fails on Android NDK (no separate libpthread). We only need transcoder sources.
+FetchContent_GetProperties(basis_universal)
+if(NOT basis_universal_POPULATED)
+    FetchContent_Populate(basis_universal)
+endif()
+
+set(BASIS_DIR "${basis_universal_SOURCE_DIR}")
+
+add_library(basisu_transcoder_min STATIC
+        ${BASIS_DIR}/transcoder/basisu_transcoder.cpp
+        ${BASIS_DIR}/zstd/zstddeclib.c
+)
+
+target_include_directories(basisu_transcoder_min PUBLIC
+        ${BASIS_DIR}/transcoder
+        ${BASIS_DIR}/zstd
+)
+
+target_compile_options(basisu_transcoder_min PRIVATE -fno-strict-aliasing)
+
+add_library(aguacero_satellite_ktx SHARED satellite_ktx_jni.cpp)
+
+target_include_directories(aguacero_satellite_ktx PRIVATE
+        ${BASIS_DIR}/transcoder
+)
+
+target_link_libraries(aguacero_satellite_ktx PRIVATE basisu_transcoder_min log)
+
+target_compile_options(aguacero_satellite_ktx PRIVATE -fno-strict-aliasing)

package/android/src/main/cpp/satellite_ktx_jni.cpp

@@ -0,0 +1,165 @@
+#include <android/log.h>
+#include <jni.h>
+#include <cstring>
+#include <mutex>
+#include <vector>
+
+#include "basisu_transcoder.h"
+
+#define LOG_TAG "AguaceroSatKtx"
+#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+std::once_flag g_basis_init;
+
+void ensure_basis_init() {
+    std::call_once(g_basis_init, []() { basist::basisu_transcoder_init(); });
+}
+
+bool try_transcode(
+        basist::ktx2_transcoder &transcoder,
+        basist::transcoder_texture_format fmt,
+        uint32_t decode_flags,
+        uint32_t width,
+        uint32_t height,
+        std::vector<uint8_t> &out,
+        basist::transcoder_texture_format &out_fmt_used) {
+    if (!basist::basis_is_format_supported(fmt, transcoder.get_basis_tex_format())) {
+        return false;
+    }
+
+    const uint32_t total_bytes =
+            basist::basis_compute_transcoded_image_size_in_bytes(fmt, width, height);
+    const uint32_t bytes_per =
+            basist::basis_get_bytes_per_block_or_pixel(fmt);
+    if (bytes_per == 0 || total_bytes == 0) {
+        return false;
+    }
+
+    const uint32_t total_blocks = total_bytes / bytes_per;
+    out.resize(total_bytes);
+
+    if (!transcoder.transcode_image_level(
+                0,
+                0,
+                0,
+                out.data(),
+                total_blocks,
+                fmt,
+                decode_flags)) {
+        out.clear();
+        return false;
+    }
+
+    out_fmt_used = fmt;
+    return true;
+}
+
+} // namespace
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_aguacerowx_reactnative_SatelliteKtxDecoder_nativeTranscodeKtx2(
+        JNIEnv *env,
+        jclass /* clazz */,
+        jbyteArray ktx2_java,
+        jint decode_flags) {
+    ensure_basis_init();
+
+    if (ktx2_java == nullptr) {
+        return nullptr;
+    }
+
+    const jsize ktx_len = env->GetArrayLength(ktx2_java);
+    if (ktx_len <= 0) {
+        return nullptr;
+    }
+
+    std::vector<uint8_t> ktx_data(static_cast<size_t>(ktx_len));
+    env->GetByteArrayRegion(
+            ktx2_java,
+            0,
+            ktx_len,
+            reinterpret_cast<jbyte *>(ktx_data.data()));
+
+    basist::ktx2_transcoder transcoder;
+    if (!transcoder.init(ktx_data.data(), static_cast<uint32_t>(ktx_data.size()))) {
+        ALOGW("ktx2_transcoder.init failed");
+        return nullptr;
+    }
+
+    if (transcoder.is_hdr()) {
+        ALOGW("HDR KTX2 not supported");
+        return nullptr;
+    }
+
+    if (!transcoder.start_transcoding()) {
+        ALOGW("start_transcoding failed");
+        return nullptr;
+    }
+
+    const uint32_t width = transcoder.get_width();
+    const uint32_t height = transcoder.get_height();
+
+    std::vector<uint8_t> out_pixels;
+    basist::transcoder_texture_format used_fmt = basist::transcoder_texture_format::cTFTotalTextureFormats;
+
+    static const basist::transcoder_texture_format k_try_order[] = {
+            basist::transcoder_texture_format::cTFASTC_LDR_4x4_RGBA,
+            basist::transcoder_texture_format::cTFETC2_RGBA,
+            basist::transcoder_texture_format::cTFRGBA32,
+    };
+
+    bool ok = false;
+    for (basist::transcoder_texture_format fmt : k_try_order) {
+        if (try_transcode(
+                    transcoder,
+                    fmt,
+                    static_cast<uint32_t>(decode_flags),
+                    width,
+                    height,
+                    out_pixels,
+                    used_fmt)) {
+            ok = true;
+            break;
+        }
+    }
+
+    if (!ok || out_pixels.empty()) {
+        ALOGW("all transcode attempts failed");
+        return nullptr;
+    }
+
+    const int32_t fmt_ordinal = static_cast<int32_t>(used_fmt);
+
+    const uint32_t header_size = 20;
+    const uint32_t payload_size = static_cast<uint32_t>(out_pixels.size());
+    const jsize total_out = static_cast<jsize>(header_size + payload_size);
+
+    jbyteArray result = env->NewByteArray(total_out);
+    if (result == nullptr) {
+        return nullptr;
+    }
+
+    uint8_t header[20];
+    header[0] = 'A';
+    header[1] = 'G';
+    header[2] = 'S';
+    header[3] = '1';
+    uint32_t w_le = width;
+    uint32_t h_le = height;
+    uint32_t psz_le = payload_size;
+    std::memcpy(header + 4, &w_le, 4);
+    std::memcpy(header + 8, &h_le, 4);
+    std::memcpy(header + 12, &fmt_ordinal, 4);
+    std::memcpy(header + 16, &psz_le, 4);
+
+    env->SetByteArrayRegion(result, 0, 20, reinterpret_cast<const jbyte *>(header));
+    env->SetByteArrayRegion(
+            result,
+            20,
+            static_cast<jsize>(payload_size),
+            reinterpret_cast<const jbyte *>(out_pixels.data()));
+
+    return result;
+}

package/android/src/main/java/com/aguacerowx/reactnative/AguaceroDebugLog.java

@@ -0,0 +1,12 @@
+package com.aguacerowx.reactnative;
+
+/**
+ * Gate verbose Aguacero logs. NEXRAD perf / bridge tracing is off by default so logcat stays usable
+ * while debugging readouts (filter {@code [Aguacero][NEXRAD][READOUT]} in Metro).
+ */
+public final class AguaceroDebugLog {
+    private AguaceroDebugLog() {}
+
+    /** When true, emit NEXRAD bridge / GL perf {@code Log.i} lines (very noisy). */
+    public static final boolean NEXRAD_NATIVE_VERBOSE = false;
+}

package/android/src/main/java/com/aguacerowx/reactnative/AguaceroPackage.java

@@ -14,6 +14,18 @@ import java.util.Collections;
 import java.util.List;
 
 public class AguaceroPackage implements ReactPackage {
+
+    static {
+        try {
+            Class<?> logCfg = Class.forName("com.mapbox.common.LogConfiguration");
+            Class<?> loggingLevel = Class.forName("com.mapbox.common.LoggingLevel");
+            @SuppressWarnings({"unchecked", "rawtypes"})
+            Object warn = Enum.valueOf((Class<? extends Enum>) loggingLevel, "WARNING");
+            logCfg.getMethod("setLoggingLevel", loggingLevel).invoke(null, warn);
+        } catch (Throwable ignored) {
+            /* Mapbox common not present or API changed */
+        }
+    }
     
     @NonNull
     @Override
@@ -29,6 +41,8 @@ public class AguaceroPackage implements ReactPackage {
     public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
         List<ViewManager> managers = new ArrayList<>();
         managers.add(new GridRenderManager());
+        managers.add(new NexradRadarManager());
+        managers.add(new SatelliteLayerManager());
         return managers;
     }
 }

package/android/src/main/java/com/aguacerowx/reactnative/AguaceroStyleLayerIds.java

@@ -0,0 +1,18 @@
+package com.aguacerowx.reactnative;
+
+/**
+ * Stable Mapbox style layer ids shared between custom layers so stacking order is explicit.
+ * <p>
+ * NEXRAD must render <strong>above</strong> the weather grid when both are registered (same
+ * {@code belowID} anchor otherwise leaves z-order undefined and the grid can fully obscure radar).
+ */
+public final class AguaceroStyleLayerIds {
+
+    /** {@link GridRenderLayerView} registers this id — do not derive from {@link View#getId()}. */
+    public static final String WEATHER_GRID_CUSTOM_LAYER = "aguacero-weather-grid-custom";
+
+    /** Mapbox id for {@link com.aguacerowx.reactnative.SatelliteLayer} — must match mapsgl default and JS {@code nwsAndroidConstants}. */
+    public static final String SATELLITE_CUSTOM_LAYER = "aguacero-satellite-layer";
+
+    private AguaceroStyleLayerIds() {}
+}

package/android/src/main/java/com/aguacerowx/reactnative/GridRenderLayer.java

@@ -135,14 +135,11 @@ public class GridRenderLayer implements CustomLayerHost {
         } else {
             this.currentVariable = variable;
         }
-        // MODIFICATION: Add detailed logging here
         this.isPtype = "ptypeRefl".equals(this.currentVariable) || "ptypeRate".equals(this.currentVariable);
-        Log.d(TAG, "setVariable called. Variable: '" + this.currentVariable + "', isPtype set to: " + this.isPtype);
     }
 
     public void setIsMRMS(boolean isMRMS) {
         this.isMRMS = isMRMS;
-        Log.d(TAG, "setIsMRMS called with: " + isMRMS);
     }
 
     public void clearData() {
@@ -159,7 +156,6 @@ public class GridRenderLayer implements CustomLayerHost {
 
         synchronized (dataLock) {
             if (pendingVertexBuffer != null && pendingIndexBuffer != null) {
-                long t0 = System.nanoTime();
                 this.indexCount = pendingIndexBuffer.capacity();
                 int vertexBytes = pendingVertexBuffer.capacity() * 4;
                 int indexBytes = pendingIndexBuffer.capacity() * 2;
@@ -176,14 +172,10 @@ public class GridRenderLayer implements CustomLayerHost {
                 GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, indexBytes, pendingIndexBuffer, GLES20.GL_STATIC_DRAW);
                 pendingVertexBuffer = null;
                 pendingIndexBuffer = null;
-                long t1 = System.nanoTime();
-                Log.d(TAG, "[Render] VBO/IBO upload: " + ((t1 - t0) / 1_000_000) + " ms | VBO=" + (vertexBytes/1024) + "KB IBO=" + (indexBytes/1024) + "KB | indices=" + indexCount);
             }
 
             if (pendingDataBuffer != null) {
-                long t0 = System.nanoTime();
                 boolean dimensionsChanged = (pendingNx != this.textureWidth || pendingNy != this.textureHeight);
-                int texBytes = pendingNx * pendingNy; // GL_ALPHA = 1 byte/pixel
 
                 this.textureWidth = pendingNx;
                 this.textureHeight = pendingNy;
@@ -209,19 +201,14 @@ public class GridRenderLayer implements CustomLayerHost {
                     GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
                     pendingDataBuffer.position(0);
                     GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_ALPHA, pendingNx, pendingNy, 0, GLES20.GL_ALPHA, GLES20.GL_UNSIGNED_BYTE, pendingDataBuffer);
-                    Log.d(TAG, "[Render] glTexImage2D (full alloc) " + pendingNx + "x" + pendingNy + " = " + (texBytes/1024) + " KB GPU");
                 } else {
                     pendingDataBuffer.position(0);
                     GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, pendingNx, pendingNy, GLES20.GL_ALPHA, GLES20.GL_UNSIGNED_BYTE, pendingDataBuffer);
-                    Log.d(TAG, "[Render] glTexSubImage2D (update) " + pendingNx + "x" + pendingNy + " = " + (texBytes/1024) + " KB");
                 }
                 pendingDataBuffer = null;
-                long t1 = System.nanoTime();
-                Log.d(TAG, "[Render] Data texture upload total: " + ((t1 - t0) / 1_000_000) + " ms");
             }
 
             if (pendingColormapBuffer != null) {
-                long t0 = System.nanoTime();
                 if (colormapTextureId == 0) {
                     int[] t = new int[1];
                     GLES20.glGenTextures(1, t, 0);
@@ -234,8 +221,6 @@ public class GridRenderLayer implements CustomLayerHost {
                 pendingColormapBuffer.position(0);
                 GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, 256, 1, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, pendingColormapBuffer);
                 pendingColormapBuffer = null;
-                long t1 = System.nanoTime();
-                Log.d(TAG, "[Render] Colormap texture upload: " + ((t1 - t0) / 1_000_000) + " ms");
             }
         }
 
@@ -554,8 +539,6 @@ public class GridRenderLayer implements CustomLayerHost {
     public void updateGeometry(ReadableMap cornersMap, ReadableMap gridDefMap) {
         if (gridDefMap == null) return;
 
-        long tGeom0 = System.nanoTime();
-
         // Pre-calculate buffer sizes to avoid ArrayList boxing entirely
         int[] counts = estimateBufferCounts(gridDefMap);
         int maxVertices = counts[0];
@@ -571,9 +554,6 @@ public class GridRenderLayer implements CustomLayerHost {
         int vertexCount = vb.position();
         int indexCount = ib.position();
 
-        long tGeom1 = System.nanoTime();
-        Log.d(TAG, "[Geometry] generateGeometryData: " + ((tGeom1 - tGeom0) / 1_000_000) + " ms | vertices=" + vertexCount + " indices=" + indexCount);
-
         if (vertexCount == 0 || indexCount == 0) {
             Log.e(TAG, "Generated geometry is empty, aborting GPU buffer update.");
             return;
@@ -601,8 +581,6 @@ public class GridRenderLayer implements CustomLayerHost {
             pendingVertexBuffer = vbFinal;
             pendingIndexBuffer = ibFinal;
         }
-
-        Log.d(TAG, "[Geometry] Buffer ready: VBO=" + (vertexCount * 4 / 1024) + "KB IBO=" + (indexCount * 2 / 1024) + "KB");
     }
     
     private boolean isGFSType(ReadableMap gridParams) {

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

@@ -27,7 +27,7 @@ import java.nio.ByteOrder;
 public class GridRenderLayerView extends FrameLayout {
 
     private final GridRenderLayer gridLayerImplementation;
-    private final String LAYER_ID = "weather-layer-" + getId();
+    private final String LAYER_ID = AguaceroStyleLayerIds.WEATHER_GRID_CUSTOM_LAYER;
     private static final String TAG = "AguaceroWX";
     private MapView mapView;
     private boolean isLayerAdded = false;

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

@@ -15,7 +15,7 @@ import java.util.concurrent.Executors;
 
 public class InspectorModule extends ReactContextBaseJavaModule {
 
-    private static final String TAG = "AguaceroWX_Perf";
+    private static final String TAG = "AguaceroInspector";
     private final ExecutorService executor = Executors.newSingleThreadExecutor();
 
     // Cache the fully decoded array so we don't re-read disk + decompress on every inspector move
@@ -37,7 +37,6 @@ public class InspectorModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getValueAtGridIndex(int i, int j, Promise promise) {
         executor.execute(() -> {
-            long t0 = System.nanoTime();
             try {
                 // Use the static fields already maintained by GridRenderLayerView
                 String filePath = GridRenderLayerView.getLastDataFilePath();
@@ -69,9 +68,7 @@ public class InspectorModule extends ReactContextBaseJavaModule {
                             && cachedNx == nx
                             && cachedNy == ny) {
                         decodedData = cachedDecodedData;
-                        Log.d(TAG, "[Inspector] Cache HIT — skipped disk read + decompress");
                     } else {
-                        long tDisk0 = System.nanoTime();
                         File file = new File(filePath);
                         if (!file.exists()) {
                             promise.resolve(null);
@@ -81,24 +78,15 @@ public class InspectorModule extends ReactContextBaseJavaModule {
                         try (FileInputStream fis = new FileInputStream(file)) {
                             fis.read(compressedData);
                         }
-                        long tDisk1 = System.nanoTime();
-                        Log.d(TAG, "[Inspector] Disk read: " + ((tDisk1 - tDisk0) / 1_000_000) + " ms, size=" + compressedData.length + " bytes");
 
-                        long tDecomp0 = System.nanoTime();
                         byte[] rawData = Zstd.decompress(compressedData, totalSize);
-                        long tDecomp1 = System.nanoTime();
-                        Log.d(TAG, "[Inspector] Zstd decompress: " + ((tDecomp1 - tDecomp0) / 1_000_000) + " ms");
 
                         // Delta decode the entire array once and cache it
-                        long tDelta0 = System.nanoTime();
                         byte[] fullDecoded = new byte[totalSize];
                         fullDecoded[0] = rawData[0];
                         for (int k = 1; k < totalSize; k++) {
                             fullDecoded[k] = (byte) (fullDecoded[k - 1] + rawData[k]);
                         }
-                        long tDelta1 = System.nanoTime();
-                        Log.d(TAG, "[Inspector] Delta decode (" + totalSize + " elements): " + ((tDelta1 - tDelta0) / 1_000_000) + " ms");
-                        Log.d(TAG, "[Inspector] Decoded array memory: " + (totalSize / 1024) + " KB");
 
                         cachedDecodedData = fullDecoded;
                         cachedFilePath = filePath;
@@ -123,9 +111,6 @@ public class InspectorModule extends ReactContextBaseJavaModule {
                         ? intermediateValue * Math.abs(intermediateValue)
                         : intermediateValue;
 
-                long t1 = System.nanoTime();
-                Log.d(TAG, "[Inspector] Total time: " + ((t1 - t0) / 1_000_000) + " ms");
-
                 promise.resolve(finalValue);
 
             } catch (Exception e) {
@@ -140,7 +125,6 @@ public class InspectorModule extends ReactContextBaseJavaModule {
         synchronized (decodedCacheLock) {
             cachedDecodedData = null;
             cachedFilePath = null;
-            Log.d(TAG, "[Inspector] Cache invalidated");
         }
     }
 }