ilabs-flir 2.3.0 → 2.3.1

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

@@ -71,7 +71,19 @@ object FlirManager {
     fun isPreferSdkRotation(): Boolean = false
     fun getBatteryLevel(): Int = -1
     fun isBatteryCharging(): Boolean = false
-    fun setPalette(name: String) { /* No-op */ }
+    fun setPalette(name: String) {
+        sdkManager?.setPalette(name)
+        // Also try to update the app's global Var.cool if possible
+        try {
+            val palettes = listOf("iron", "rainbow", "grayscale", "arctic", "lava", "contrast", "hotcold", "medical")
+            val idx = palettes.indexOf(name.lowercase())
+            if (idx != -1) {
+                // If we found the index, we use the raw value. 
+                // But if the name itself is passed as a number or from a loop, handle it.
+                updateAcol(idx.toFloat())
+            }
+        } catch (e: Exception) {}
+    }
     fun getAvailablePalettes(): List<String> = emptyList()
     
     /**
@@ -227,6 +239,13 @@ object FlirManager {
     }
     
      /**
+     * Capture a high-fidelity radiometric snapshot (saves thermal data)
+     */
+    fun captureRadiometricSnapshot(path: String) {
+        sdkManager?.captureRadiometricSnapshot(path)
+    }
+
+    /**
      * Get latest frame as file path (for RN)
      */
     fun getLatestFramePath(): String? {
@@ -401,6 +420,33 @@ object FlirManager {
     fun enableEmulatorMode() = startDiscovery()
     fun forceEmulatorMode(type: String = "FLIR_ONE_EDGE") { startDiscovery() }
     fun setPreferredEmulatorType(type: String) { }
-    fun updateAcol(value: Float) { }
+    fun updateAcol(value: Float) {
+        Log.d(TAG, "updateAcol: $value")
+        // Use reflection to update ilabs.libs.io.data.Var.cool to avoid circular dependency
+        try {
+            val varClass = Class.forName("ilabs.libs.io.data.Var")
+            val coolField = varClass.getField("cool")
+            
+            // Modular logic for palettes: if index > 7, wrap around (17 mod 8)
+            // But we keep shader variants (14, 15, 16) as-is if within that range
+            val rawIdx = value.toInt()
+            var shaderIdx = rawIdx
+            if (shaderIdx > 16) {
+                shaderIdx = shaderIdx % 16 // Shader loop
+            }
+            
+            coolField.set(null, shaderIdx)
+            Log.d(TAG, "Updated Var.cool to $shaderIdx via reflection (raw=$rawIdx)")
+
+            // If we are in FLIR mode, also notify the SDK palette with modular loop
+            val palettes = listOf("iron", "rainbow", "grayscale", "arctic", "lava", "contrast", "hotcold", "medical")
+            val paletteIdx = rawIdx % palettes.size
+            val safeIdx = if (paletteIdx < 0) paletteIdx + palettes.size else paletteIdx
+            sdkManager?.setPalette(palettes[safeIdx])
+            
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not update Var.cool via reflection: ${e.message}")
+        }
+    }
     fun destroy() { stop() }
 }

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

@@ -256,6 +256,28 @@ class FlirModule(private val reactContext: ReactApplicationContext) : ReactConte
             promise?.reject("ERR_FLIR_STOP", e)
         }
     }
+
+    @ReactMethod
+    fun updateAcol(value: Float, promise: Promise?) {
+        try {
+            FlirManager.updateAcol(value)
+            promise?.resolve(true)
+        } catch (e: Exception) {
+            promise?.reject("ERR_FLIR_ACOL", e)
+        }
+    }
+
+    @ReactMethod
+    fun setPalette(name: String?, promise: Promise?) {
+        try {
+            if (name != null) {
+                FlirManager.setPalette(name)
+            }
+            promise?.resolve(true)
+        } catch (e: Exception) {
+            promise?.reject("ERR_FLIR_PALETTE", e)
+        }
+    }
     
     @ReactMethod
     fun initializeSDK(promise: Promise?) {

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

@@ -8,7 +8,10 @@ import android.util.Log;
 import com.flir.thermalsdk.ErrorCode;
 import com.flir.thermalsdk.androidsdk.ThermalSdkAndroid;
 import com.flir.thermalsdk.androidsdk.image.BitmapAndroid;
+import com.flir.thermalsdk.image.Palette;
+import com.flir.thermalsdk.image.PaletteManager;
 import com.flir.thermalsdk.image.Point;
+import com.flir.thermalsdk.image.ThermalImage;
 import com.flir.thermalsdk.image.ThermalValue;
 import com.flir.thermalsdk.live.AuthenticationResponse;
 import com.flir.thermalsdk.live.Camera;
@@ -48,8 +51,10 @@ public class FlirSdkManager {
     private Stream activeStream;
     private final List<Identity> discoveredDevices = Collections.synchronizedList(new ArrayList<>());
     private volatile Bitmap latestBitmap;
+    private volatile String currentPaletteName = "iron";
     private final AtomicBoolean isProcessingFrame = new AtomicBoolean(false);
     private boolean useHalfScale = false;
+    private String pendingSnapshotPath = null;
 
     // Listener
     private Listener listener;
@@ -337,14 +342,42 @@ public class FlirSdkManager {
                                 if (streamer != null && activeStream != null) {
                                     streamer.update();
                                     
-                                    // createBitmap is safe to do here or in executor
-                                    Bitmap bitmap = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
-                                    if (bitmap != null) {
-                                        latestBitmap = bitmap;
-                                        if (listener != null) {
-                                            listener.onFrame(bitmap);
+                                    final String paletteToApply = currentPaletteName;
+                                    final String snapshotPath = pendingSnapshotPath;
+                                    pendingSnapshotPath = null;
+
+                                    streamer.withThermalImage(thermalImage -> {
+                                        // 1. Apply Palette
+                                        if (paletteToApply != null) {
+                                            Palette palette = 
+                                                PaletteManager.getDefaultPalettes().stream()
+                                                    .filter(p -> p.name.equalsIgnoreCase(paletteToApply))
+                                                    .findFirst()
+                                                    .orElse(null);
+                                            if (palette != null) {
+                                                thermalImage.setPalette(palette);
+                                            }
                                         }
-                                    }
+
+                                        // 2. Save Radiometric Snapshot if requested
+                                        if (snapshotPath != null) {
+                                            try {
+                                                thermalImage.saveAs(snapshotPath);
+                                                Log.i(TAG, "Radiometric snapshot saved to: " + snapshotPath);
+                                            } catch (java.io.IOException e) {
+                                                Log.e(TAG, "Failed to save radiometric snapshot", e);
+                                            }
+                                        }
+
+                                        // 3. Generate Bitmap for display
+                                        Bitmap bitmap = BitmapAndroid.createBitmap(thermalImage.getImage()).getBitMap();
+                                        if (bitmap != null) {
+                                            latestBitmap = bitmap;
+                                            if (listener != null) {
+                                                listener.onFrame(bitmap);
+                                            }
+                                        }
+                                    });
                                 }
                             } catch (Exception e) {
                                 Log.e(TAG, "Frame processing error", e);
@@ -423,6 +456,16 @@ public class FlirSdkManager {
     }
 
     // ==================== LISTENERS ====================
+    
+    public void setPalette(String paletteName) {
+        this.currentPaletteName = paletteName;
+        Log.d(TAG, "Requested palette: " + paletteName);
+    }
+
+    public void captureRadiometricSnapshot(String path) {
+        this.pendingSnapshotPath = path;
+        Log.d(TAG, "Pending radiometric snapshot: " + path);
+    }
 
     private final DiscoveryEventListener discoveryListener = new DiscoveryEventListener() {
         @Override

package/ios/Flir/src/FlirManager.swift

@@ -66,6 +66,10 @@ import ThermalSDK
     // Internal synchronization
     private let stateLock = NSObject()
     
+    // Palette and Snapshot state
+    private var currentPaletteName: String = "iron"
+    private var pendingSnapshotPath: String?
+    
     // Dedicated render queue for frame processing (matches sample app pattern)
     private let renderQueue = DispatchQueue(label: "com.flir.render")
     
@@ -506,11 +510,22 @@ import ThermalSDK
     }
     
     @objc public func setPalette(_ name: String) {
-        // stub
+        self.currentPaletteName = name
+        NSLog("[FlirManager] Requested palette: \(name)")
     }
     
     @objc public func setPaletteFromAcol(_ acol: Float) {
-        // stub
+        // Map acol (0..7) to palette names
+        let palettes = ["iron", "rainbow", "grayscale", "arctic", "lava", "contrast", "hotcold", "medical"]
+        let idx = Int(acol)
+        if idx >= 0 && idx < palettes.count {
+            setPalette(palettes[idx])
+        }
+    }
+
+    @objc public func captureRadiometricSnapshot(_ path: String) {
+        self.pendingSnapshotPath = path
+        NSLog("[FlirManager] Pending radiometric snapshot: \(path)")
     }
     
     @objc public func retainClient(_ clientId: String) {
@@ -684,8 +699,30 @@ extension FlirManager: FLIRStreamDelegate {
                 return
             }
 
+            let paletteToApply = self.currentPaletteName
+            let snapshotPath = self.pendingSnapshotPath
+            self.pendingSnapshotPath = nil
+
             do {
                 try streamer.update()
+                
+                streamer.withThermalImage { thermalImage in
+                    // 1. Apply Palette
+                    if let palette = thermalImage.paletteManager.getDefaultPalettes().first(where: { $0.name.lowercased() == paletteToApply.lowercased() }) {
+                        thermalImage.palette = palette
+                    }
+
+                    // 2. Save Radiometric Snapshot if requested
+                    if let path = snapshotPath {
+                        do {
+                            try thermalImage.save(to: path)
+                            NSLog("[FlirManager] Radiometric snapshot saved to: \(path)")
+                        } catch {
+                            NSLog("[FlirManager] Failed to save radiometric snapshot: \(error)")
+                        }
+                    }
+                }
+                
                 NSLog("[FLIR-TRACE 3️⃣] Streamer updated successfully")
             } catch {
                 NSLog("[FLIR-TRACE ❌] Streamer update failed: \(error)")

package/ios/Flir/src/FlirModule.m

@@ -479,6 +479,34 @@ RCT_EXPORT_METHOD(setPreferSdkRotation : (BOOL)prefer resolver : (
   });
 }
 
+RCT_EXPORT_METHOD(setPalette : (NSString *)name resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    id manager = flir_manager_shared();
+    if (manager &&
+        [manager respondsToSelector:sel_registerName("setPalette:")]) {
+      ((void (*)(id, SEL, id))objc_msgSend)(manager,
+                                            sel_registerName("setPalette:"),
+                                            name);
+    }
+    if (resolve) resolve(@(YES));
+  });
+}
+
+RCT_EXPORT_METHOD(captureRadiometricSnapshot : (NSString *)path resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    id manager = flir_manager_shared();
+    if (manager &&
+        [manager respondsToSelector:sel_registerName("captureRadiometricSnapshot:")]) {
+      ((void (*)(id, SEL, id))objc_msgSend)(manager,
+                                            sel_registerName("captureRadiometricSnapshot:"),
+                                            path);
+    }
+    if (resolve) resolve(@(YES));
+  });
+}
+
 RCT_EXPORT_METHOD(isPreferSdkRotation : (RCTPromiseResolveBlock)
                       resolve rejecter : (RCTPromiseRejectBlock)reject) {
   dispatch_async(dispatch_get_main_queue(), ^{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilabs-flir",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "FLIR Thermal SDK for React Native - iOS & Android (bundled at compile time via postinstall)",
   "main": "src/index.js",
   "types": "src/index.d.ts",