ilabs-flir 2.2.24 → 2.2.27

package/android/Flir/src/main/java/flir/android/FlirManager.kt

@@ -180,8 +180,10 @@ object FlirManager {
     }
     
     fun getTemperatureAtNormalized(nx: Double, ny: Double): Double? {
-        // Not implemented in simplified version
-        return null 
+        val bitmap = latestBitmap ?: return null
+        val px = (nx * bitmap.width).toInt().coerceIn(0, bitmap.width - 1)
+        val py = (ny * bitmap.height).toInt().coerceIn(0, bitmap.height - 1)
+        return getTemperatureAt(px, py)
     }
     
     fun getTemperatureAtPoint(x: Int, y: Int): Double? = getTemperatureAt(x, y)
@@ -255,9 +257,9 @@ object FlirManager {
                 return
             }
 
-            // THROTTLE: Limit to ~15 FPS to prevent UI thread flooding
+            // THROTTLE: Limit to ~30 FPS for smoother streaming
             val now = System.currentTimeMillis()
-            if (now - lastEmitMs.get() < 66) { // 66ms ~= 15 FPS
+            if (now - lastEmitMs.get() < 33) { // 33ms ~= 30 FPS
                 return
             }
             lastEmitMs.set(now)

package/android/Flir/src/main/java/flir/android/FlirModule.kt

@@ -67,6 +67,16 @@ class FlirModule(private val reactContext: ReactApplicationContext) : ReactConte
             promise.reject("ERR_FLIR_SAMPLE", e)
         }
     }
+
+    @ReactMethod
+    fun getTemperatureAtNormalized(nx: Double, ny: Double, promise: Promise) {
+        try {
+            val temp = FlirManager.getTemperatureAtNormalized(nx, ny)
+            if (temp != null) promise.resolve(temp) else promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_TEMP_NORM", e)
+        }
+    }
     
     @ReactMethod
     fun isEmulator(promise: Promise) {

package/android/Flir/src/main/java/flir/android/FlirSdkManager.java

@@ -1,6 +1,7 @@
 package flir.android;
 
 import android.content.Context;
+import android.content.SharedPreferences;
 import android.graphics.Bitmap;
 import android.util.Log;
 
@@ -9,6 +10,7 @@ import com.flir.thermalsdk.androidsdk.ThermalSdkAndroid;
 import com.flir.thermalsdk.androidsdk.image.BitmapAndroid;
 import com.flir.thermalsdk.image.Point;
 import com.flir.thermalsdk.image.ThermalValue;
+import com.flir.thermalsdk.live.AuthenticationResponse;
 import com.flir.thermalsdk.live.Camera;
 import com.flir.thermalsdk.live.CommunicationInterface;
 import com.flir.thermalsdk.live.ConnectParameters;
@@ -25,6 +27,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Simplified FLIR SDK Manager - matches sample app pattern
@@ -45,6 +48,8 @@ public class FlirSdkManager {
     private Stream activeStream;
     private final List<Identity> discoveredDevices = Collections.synchronizedList(new ArrayList<>());
     private volatile Bitmap latestBitmap;
+    private final AtomicBoolean isProcessingFrame = new AtomicBoolean(false);
+    private boolean useHalfScale = false;
 
     // Listener
     private Listener listener;
@@ -173,6 +178,57 @@ public class FlirSdkManager {
 
                 Log.d(TAG, "Connecting to: " + identity.deviceId);
                 camera = new Camera();
+
+                // ── Authenticate for NETWORK cameras (required by FLIR SDK) ──
+                // Matches the official NetworkCamera sample app pattern.
+                // The FLIR One Edge Pro is a network camera and will reject
+                // connections without prior authentication + trust approval.
+                if (identity.communicationInterface == CommunicationInterface.NETWORK) {
+                    Log.d(TAG, "Network camera detected — authenticating...");
+
+                    // Use a persistent application name (workaround for camera bug
+                    // where re-auth with a different name conflicts). Same pattern
+                    // as CameraAuthName in the NetworkCamera sample.
+                    SharedPreferences prefs = context.getSharedPreferences(
+                            "flir_auth", Context.MODE_PRIVATE);
+                    String authName = prefs.getString("auth_name", null);
+                    if (authName == null) {
+                        authName = context.getPackageName() + "-" +
+                                (System.currentTimeMillis() % 10000);
+                        prefs.edit().putString("auth_name", authName).apply();
+                    }
+
+                    AuthenticationResponse response;
+                    int attempts = 0;
+                    final int MAX_AUTH_ATTEMPTS = 30; // 30 seconds max wait
+                    do {
+                        response = camera.authenticate(identity, authName,
+                                41 * 1000); // 41-second timeout per attempt
+                        Log.d(TAG, "Auth attempt " + (attempts + 1) +
+                                " status: " + response.authenticationStatus);
+
+                        if (response.authenticationStatus ==
+                                AuthenticationResponse.AuthenticationStatus.PENDING) {
+                            // Camera is waiting for user to press "Trust" on its screen
+                            Thread.sleep(1000);
+                        }
+                        attempts++;
+                    } while (response.authenticationStatus ==
+                            AuthenticationResponse.AuthenticationStatus.PENDING
+                            && attempts < MAX_AUTH_ATTEMPTS);
+
+                    if (response.authenticationStatus !=
+                            AuthenticationResponse.AuthenticationStatus.APPROVED) {
+                        Log.e(TAG, "Authentication rejected/timed out: " +
+                                response.authenticationStatus);
+                        camera = null;
+                        notifyError("Camera authentication failed. " +
+                                "Check the camera screen for a trust prompt.");
+                        return;
+                    }
+                    Log.d(TAG, "Authentication approved");
+                }
+
                 camera.connect(identity, connectionStatusListener, new ConnectParameters());
                 Log.d(TAG, "Connected to: " + identity.deviceId);
 
@@ -221,6 +277,15 @@ public class FlirSdkManager {
         executor.execute(this::startStreamInternal);
     }
 
+    public void setUseHalfScale(boolean useHalfScale) {
+        this.useHalfScale = useHalfScale;
+        executor.execute(() -> {
+            if (streamer != null) {
+                // We'll apply this when the streamer is created or updated
+            }
+        });
+    }
+
     private void startStreamInternal() {
         if (camera == null) {
             notifyError("Not connected");
@@ -258,22 +323,27 @@ public class FlirSdkManager {
             // Start stream with simple callback (matches sample app)
             thermalStream.start(
                     unused -> {
-                        executor.execute(() -> {
-                            try {
-                                if (streamer != null && activeStream != null) {
-                                    streamer.update();
-                                    Bitmap bitmap = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
-                                    if (bitmap != null) {
-                                        latestBitmap = bitmap;
-                                        if (listener != null) {
-                                            listener.onFrame(bitmap);
+                        // Skip if previous frame still processing
+                        if (isProcessingFrame.compareAndSet(false, true)) {
+                            executor.execute(() -> {
+                                try {
+                                    if (streamer != null && activeStream != null) {
+                                        streamer.update();
+                                        Bitmap bitmap = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
+                                        if (bitmap != null) {
+                                            latestBitmap = bitmap;
+                                            if (listener != null) {
+                                                listener.onFrame(bitmap);
+                                            }
                                         }
                                     }
+                                } catch (Exception e) {
+                                    Log.e(TAG, "Frame error", e);
+                                } finally {
+                                    isProcessingFrame.set(false);
                                 }
-                            } catch (Exception e) {
-                                Log.e(TAG, "Frame error", e);
-                            }
-                        });
+                            });
+                        }
                     },
                     error -> {
                         executor.execute(() -> {