@aguacerowx/react-native 0.0.41 → 0.0.42

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

@@ -1,107 +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;
-    }
+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;
+    }
 }

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

@@ -1,152 +1,271 @@
-package com.aguacerowx.reactnative;
-
-import androidx.annotation.NonNull;
-import android.util.Base64;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.Promise;  // CHANGED: Import Promise instead of 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, Promise promise) {  // CHANGED: Use Promise instead of Callback
-        final int taskToken = this.currentRunToken;
-        executorService.execute(() -> {
-            FileOutputStream fos = null;
-            try {
-                if (taskToken != this.currentRunToken) {
-                    return; // Task was cancelled
-                }
-
-                OkHttpClient client = OkHttpClientProvider.getOkHttpClient();
-
-                String urlString = options.getString("url");
-                String apiKey = options.getString("apiKey");
-                String bundleId = options.getString("bundleId");
-
-                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;
-                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();
-                }
-
-                JSONObject jsonResponse = new JSONObject(responseString);
-                if (!jsonResponse.has("data") || !jsonResponse.has("encoding")) {
-                    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")) {
-                    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);
-
-                promise.resolve(responseMap);  // CHANGED: Use promise.resolve() instead of callback
-
-            } catch (Exception e) {
-                if (taskToken == this.currentRunToken) {
-                    android.util.Log.e("AguaceroWX", "Error processing frame", e);
-                    promise.reject("PROCESSING_ERROR", e.getMessage(), e);  // CHANGED: Use promise.reject() instead of callback
-                }
-            } finally {
-                if (fos != null) {
-                    try {
-                        fos.close();
-                    } catch (IOException e) {
-                        android.util.Log.e("AguaceroWX", "Error closing file stream", e);
-                    }
-                }
-            }
-        });
-    }
+package com.aguacerowx.reactnative;
+
+import androidx.annotation.NonNull;
+import android.util.Base64;
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+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 org.json.JSONObject;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.ConnectionPool;
+import okhttp3.Dispatcher;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+
+public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
+
+    private static final String TAG = "AguaceroWX_Perf";
+    private final AtomicInteger currentRunToken = new AtomicInteger(0);
+    private final ReactApplicationContext reactContext;
+    private final OkHttpClient httpClient;
+    
+    // FIX 1: Use an ExecutorService instead of "new Thread()". 
+    // CachedThreadPool reuses threads and scales down when idle.
+    private final ExecutorService taskExecutor = Executors.newCachedThreadPool();
+
+    // FIX 2: Reduce concurrency to 4. 
+    // 6 concurrent JSON parsings + Base64 decodings causes GC thrashing on mobile.
+    // 4 is the "sweet spot" for throughput vs memory.
+    private static final int MAX_CONCURRENT = 4;
+    private final Semaphore semaphore = new Semaphore(MAX_CONCURRENT, true);
+
+    private final Set<Call> activeCalls = Collections.newSetFromMap(new ConcurrentHashMap<>());
+
+    WeatherFrameProcessorModule(ReactApplicationContext context) {
+        super(context);
+        this.reactContext = context;
+
+        Dispatcher dispatcher = new Dispatcher();
+        dispatcher.setMaxRequests(64);
+        dispatcher.setMaxRequestsPerHost(32);
+
+        this.httpClient = new OkHttpClient.Builder()
+            .dispatcher(dispatcher)
+            .connectionPool(new ConnectionPool(MAX_CONCURRENT, 30, TimeUnit.SECONDS))
+            .connectTimeout(15, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+            .writeTimeout(15, TimeUnit.SECONDS)
+            .build();
+
+        Log.d(TAG, "[FrameProcessor] Initialized | MAX_CONCURRENT=" + MAX_CONCURRENT);
+    }
+
+    @ReactMethod
+    public void cancelAllFrames() {
+        int newToken = currentRunToken.incrementAndGet();
+
+        // Hard-cancel every tracked OkHttp call
+        int cancelledCount = 0;
+        for (Call call : activeCalls) {
+            if (!call.isCanceled()) {
+                call.cancel();
+                cancelledCount++;
+            }
+        }
+        activeCalls.clear();
+
+        // Release all semaphore permits to unblock the Executor queue
+        semaphore.drainPermits();
+        semaphore.release(MAX_CONCURRENT);
+
+        Log.d(TAG, "[FrameProcessor] cancelAllFrames — token: " + newToken
+                + " | hard-cancelled " + cancelledCount + " in-flight calls"
+                + " | semaphore reset to " + MAX_CONCURRENT);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "WeatherFrameProcessorModule";
+    }
+
+    @ReactMethod
+    public void processFrame(ReadableMap options, Promise promise) {
+        final int taskToken = currentRunToken.get();
+        final long tTotal0 = System.nanoTime();
+
+        final String urlString = options.getString("url");
+        final String apiKey = options.getString("apiKey");
+        final String bundleId = options.hasKey("bundleId") ? options.getString("bundleId") : null;
+
+        // FIX 3: Submit to Executor instead of spinning up a raw OS thread
+        taskExecutor.execute(() -> {
+            try {
+                if (currentRunToken.get() != taskToken) return;
+
+                // This blocks the Executor thread (which is fine, it's a pool) 
+                // until a slot is available
+                semaphore.acquire();
+
+                if (currentRunToken.get() != taskToken) {
+                    semaphore.release();
+                    return;
+                }
+
+                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();
+
+                final long tNet0 = System.nanoTime();
+                Call call = httpClient.newCall(request);
+                activeCalls.add(call);
+
+                call.enqueue(new Callback() {
+                    @Override
+                    public void onFailure(@NonNull Call call, @NonNull IOException e) {
+                        activeCalls.remove(call);
+                        semaphore.release(); // IMPORTANT: Release immediately on fail
+                        
+                        if (currentRunToken.get() != taskToken) return;
+                        if (!call.isCanceled()) {
+                            Log.e(TAG, "[FrameProcessor] Network failure: " + e.getMessage());
+                            promise.reject("NETWORK_ERROR", e.getMessage(), e);
+                        }
+                    }
+
+                    @Override
+                    public void onResponse(@NonNull Call call, @NonNull Response response) {
+                        activeCalls.remove(call);
+                        // NOTE: We hold the semaphore until processing is done to prevent
+                        // CPU saturation from JSON parsing.
+                        
+                        // Check token immediately
+                        if (currentRunToken.get() != taskToken) {
+                            response.close();
+                            semaphore.release();
+                            return;
+                        }
+
+                        FileOutputStream fos = null;
+                        try {
+                            long tNet1 = System.nanoTime();
+                            Log.d(TAG, "[FrameProcessor] Network: " + ((tNet1 - tNet0) / 1_000_000) + " ms");
+
+                            if (!response.isSuccessful()) {
+                                promise.reject("HTTP_ERROR", "HTTP " + response.code());
+                                return;
+                            }
+
+                            ResponseBody body = response.body();
+                            if (body == null) {
+                                promise.reject("NO_DATA", "Response body was null");
+                                return;
+                            }
+
+                            byte[] bodyBytes = body.bytes();
+
+                            if (currentRunToken.get() != taskToken) return;
+
+                            // JSON parse
+                            long tJson0 = System.nanoTime();
+                            // This line is the memory killer. We convert bytes -> String -> JSONObject.
+                            String jsonString = new String(bodyBytes);
+                            bodyBytes = null; // FIX 4: Nullify immediately to help GC
+                            
+                            JSONObject jsonResponse = new JSONObject(jsonString);
+                            jsonString = null; // FIX 4: Nullify immediately
+
+                            if (!jsonResponse.has("data") || !jsonResponse.has("encoding")) {
+                                promise.reject("INVALID_RESPONSE", "Invalid API response structure");
+                                return;
+                            }
+                            
+                            String b64CompressedData = jsonResponse.getString("data");
+                            JSONObject encoding = jsonResponse.getJSONObject("encoding");
+                            
+                            // Don't need the huge JSON object anymore
+                            jsonResponse = null; 
+                            
+                            long tJson1 = System.nanoTime();
+                            Log.d(TAG, "[FrameProcessor] JSON parse: " + ((tJson1 - tJson0) / 1_000_000) + " ms");
+
+                            if (currentRunToken.get() != taskToken) return;
+
+                            // Base64 decode
+                            long tB640 = System.nanoTime();
+                            byte[] compressedData = Base64.decode(b64CompressedData, Base64.DEFAULT);
+                            b64CompressedData = null; // FIX 4: Nullify immediately
+                            
+                            long tB641 = System.nanoTime();
+                            Log.d(TAG, "[FrameProcessor] Base64 decode: " + ((tB641 - tB640) / 1_000_000) + " ms, size: " + compressedData.length);
+
+                            if (currentRunToken.get() != taskToken) return;
+
+                            // Disk write
+                            long tDisk0 = System.nanoTime();
+                            File cacheDir = reactContext.getCacheDir();
+                            // Use a unique name based on hash
+                            String fileName = "frame_" + urlString.hashCode() + ".zst";
+                            File dataFile = new File(cacheDir, fileName);
+                            
+                            fos = new FileOutputStream(dataFile);
+                            fos.write(compressedData);
+                            fos.flush();
+                            
+                            long tDisk1 = System.nanoTime();
+                            Log.d(TAG, "[FrameProcessor] Disk write: " + ((tDisk1 - tDisk0) / 1_000_000) + " ms");
+
+                            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"));
+                            }
+
+                            long tTotal1 = System.nanoTime();
+                            Log.d(TAG, "[FrameProcessor] TOTAL processFrame: " + ((tTotal1 - tTotal0) / 1_000_000) + " ms");
+
+                            promise.resolve(responseMap);
+
+                        } catch (Exception e) {
+                            if (currentRunToken.get() == taskToken) {
+                                Log.e(TAG, "[FrameProcessor] Error: " + e.getMessage(), e);
+                                promise.reject("PROCESSING_ERROR", e.getMessage(), e);
+                            }
+                        } finally {
+                            // FIX 5: Ensure resources are closed and semaphore is released
+                            if (fos != null) {
+                                try { fos.close(); } catch (IOException ex) { /* ignore */ }
+                            }
+                            response.close(); 
+                            semaphore.release();
+                        }
+                    }
+                });
+
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                // If interrupted while waiting for semaphore, just exit
+            } catch (Exception e) {
+                promise.reject("EXECUTION_ERROR", e.getMessage());
+            }
+        });
+    }
 }