ilabs-flir 2.3.1 → 2.3.3

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

@@ -10,6 +10,7 @@ import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.uimanager.ThemedReactContext
 import com.flir.thermalsdk.live.Identity
+import com.flir.thermalsdk.image.PaletteManager
 import java.io.File
 import java.io.FileOutputStream
 import java.util.concurrent.atomic.AtomicLong
@@ -75,16 +76,20 @@ object FlirManager {
         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 palettes = getAvailablePalettes()
             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()
+    fun getAvailablePalettes(): List<String> {
+        return try {
+            PaletteManager.getDefaultPalettes().map { it.name }
+        } catch (e: Exception) {
+            listOf("grayscale", "iron", "rainbow", "arctic", "lava", "contrast", "hotcold", "medical")
+        }
+    }
     
     /**
      * Initialize the FLIR SDK
@@ -102,6 +107,15 @@ object FlirManager {
         
         isInitialized = true
         Log.i(TAG, "FlirManager initialized")
+        
+        // Generate palette icons on background thread
+        Thread {
+            try {
+                generatePaletteIcons(context)
+            } catch (e: Exception) {
+                Log.e(TAG, "Initial palette icon generation failed", e)
+            }
+        }.start()
     }
     
     /**
@@ -241,8 +255,8 @@ object FlirManager {
      /**
      * Capture a high-fidelity radiometric snapshot (saves thermal data)
      */
-    fun captureRadiometricSnapshot(path: String) {
-        sdkManager?.captureRadiometricSnapshot(path)
+    fun captureRadiometricSnapshot(path: String, callback: FlirSdkManager.SnapshotCallback? = null) {
+        sdkManager?.captureRadiometricSnapshot(path, callback)
     }
 
     /**
@@ -438,15 +452,74 @@ object FlirManager {
             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])
+            // If we are in FLIR mode, also notify the SDK palette using the official SDK palette list
+            val sdkPalettes = PaletteManager.getDefaultPalettes()
+            val paletteNames = sdkPalettes.map { it.name }
+            Log.d(TAG, "True FLIR Palettes: $paletteNames")
+            
+            val maxEff = sdkPalettes.size
+            val paletteIdx = rawIdx % maxEff
+            val safeIdx = if (paletteIdx < 0) paletteIdx + maxEff else paletteIdx
+            
+            val targetPaletteName = paletteNames[safeIdx]
+            Log.d(TAG, "Applying true FLIR palette: $targetPaletteName (index: $safeIdx, max: $maxEff)")
+            
+            sdkManager?.setPalette(targetPaletteName)
             
         } catch (e: Exception) {
             Log.w(TAG, "Could not update Var.cool via reflection: ${e.message}")
         }
     }
+
+    /**
+     * Generate icons for all default palettes and save to cache.
+     */
+    fun generatePaletteIcons(context: Context): List<Map<String, String>> {
+        val results = mutableListOf<Map<String, String>>()
+        try {
+            val palettes = PaletteManager.getDefaultPalettes()
+            val dir = File(context.cacheDir, "flir_palettes")
+            if (!dir.exists()) dir.mkdirs()
+
+            for (palette in palettes) {
+                val iconFile = File(dir, "${palette.name.lowercase()}.png")
+                if (!iconFile.exists()) {
+                    try {
+                        // Common method names for palette preview in FLIR SDK: getBitmap(), getIcon()
+                        val bitmap = try {
+                            val m = palette.javaClass.getMethod("getBitmap")
+                            m.invoke(palette) as? Bitmap
+                        } catch (e: Exception) {
+                            try {
+                                val m = palette.javaClass.getMethod("getIcon")
+                                m.invoke(palette) as? Bitmap
+                            } catch (e2: Exception) { null }
+                        }
+
+                        bitmap?.let {
+                            FileOutputStream(iconFile).use { out ->
+                                it.compress(Bitmap.CompressFormat.PNG, 100, out)
+                            }
+                        }
+                    } catch (e: Exception) {
+                        Log.w(TAG, "Failed to save icon for ${palette.name}: ${e.message}")
+                    }
+                }
+                results.add(mapOf(
+                    "name" to palette.name,
+                    "uri" to if (iconFile.exists()) "file://${iconFile.absolutePath}" else ""
+                ))
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Palette icon generation error", e)
+        }
+        return results
+    }
+
+    fun getPalettesWithIcons(context: Context? = null): List<Map<String, String>> {
+        val ctx = context ?: reactContext ?: return emptyList()
+        return generatePaletteIcons(ctx)
+    }
+
     fun destroy() { stop() }
 }

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

@@ -137,6 +137,36 @@ class FlirModule(private val reactContext: ReactApplicationContext) : ReactConte
         }
     }
     
+    @ReactMethod
+    fun getAvailablePalettes(promise: Promise?) {
+        try {
+            val palettes = FlirManager.getAvailablePalettes()
+            val result = com.facebook.react.bridge.Arguments.createArray()
+            palettes.forEach { result.pushString(it) }
+            promise?.resolve(result)
+        } catch (e: Exception) {
+            promise?.reject("ERR_FLIR_PALETTES", e)
+        }
+    }
+
+    @ReactMethod
+    fun getPalettesWithIcons(promise: Promise?) {
+        try {
+            val palettes = FlirManager.getPalettesWithIcons(reactContext)
+            val result = com.facebook.react.bridge.Arguments.createArray()
+            
+            palettes.forEach { p ->
+                val map = com.facebook.react.bridge.Arguments.createMap()
+                map.putString("name", p["name"])
+                map.putString("uri", p["uri"])
+                result.pushMap(map)
+            }
+            promise?.resolve(result)
+        } catch (e: Exception) {
+            promise?.reject("ERR_FLIR_PALETTE_ICONS", e)
+        }
+    }
+
     @ReactMethod
     fun getDiscoveredDevices(promise: Promise?) {
         try {
@@ -257,6 +287,20 @@ class FlirModule(private val reactContext: ReactApplicationContext) : ReactConte
         }
     }
 
+    @ReactMethod
+    fun setSaveRadiometric(enabled: Boolean, promise: Promise?) {
+        try {
+            val varClass = Class.forName("ilabs.libs.io.data.Var")
+            val field = varClass.getField("saveRadiometric")
+            field.set(null, enabled)
+            Log.d(TAG, "Updated Var.saveRadiometric to $enabled via reflection")
+            promise?.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not update Var.saveRadiometric via reflection: ${e.message}")
+            promise?.reject("ERR_FLIR_SAVE_RADIOMETRIC", e)
+        }
+    }
+
     @ReactMethod
     fun updateAcol(value: Float, promise: Promise?) {
         try {

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

@@ -73,6 +73,13 @@ public class FlirSdkManager {
         void onError(String message);
     }
 
+    public interface SnapshotCallback {
+        void onSnapshotSaved(String path);
+        void onSnapshotError(String message);
+    }
+
+    private SnapshotCallback snapshotCallback;
+
     private FlirSdkManager(Context context) {
         this.context = context.getApplicationContext();
     }
@@ -364,13 +371,19 @@ public class FlirSdkManager {
                                             try {
                                                 thermalImage.saveAs(snapshotPath);
                                                 Log.i(TAG, "Radiometric snapshot saved to: " + snapshotPath);
+                                                if (snapshotCallback != null) {
+                                                    snapshotCallback.onSnapshotSaved(snapshotPath);
+                                                }
                                             } catch (java.io.IOException e) {
                                                 Log.e(TAG, "Failed to save radiometric snapshot", e);
+                                                if (snapshotCallback != null) {
+                                                    snapshotCallback.onSnapshotError(e.getMessage());
+                                                }
                                             }
                                         }
 
                                         // 3. Generate Bitmap for display
-                                        Bitmap bitmap = BitmapAndroid.createBitmap(thermalImage.getImage()).getBitMap();
+                                        Bitmap bitmap = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
                                         if (bitmap != null) {
                                             latestBitmap = bitmap;
                                             if (listener != null) {
@@ -462,8 +475,9 @@ public class FlirSdkManager {
         Log.d(TAG, "Requested palette: " + paletteName);
     }
 
-    public void captureRadiometricSnapshot(String path) {
+    public void captureRadiometricSnapshot(String path, SnapshotCallback callback) {
         this.pendingSnapshotPath = path;
+        this.snapshotCallback = callback;
         Log.d(TAG, "Pending radiometric snapshot: " + path);
     }
 

package/ios/Flir/src/FlirManager.swift

@@ -91,6 +91,11 @@ import ThermalSDK
     private override init() {
         super.init()
         NSLog("[FlirManager] Initialized")
+        
+        // Generate palette icons on background thread
+        DispatchQueue.global().async {
+            self.generatePaletteIcons()
+        }
     }
     
     // MARK: - Public State
@@ -515,14 +520,73 @@ import ThermalSDK
     }
     
     @objc public func setPaletteFromAcol(_ acol: Float) {
-        // Map acol (0..7) to palette names
-        let palettes = ["iron", "rainbow", "grayscale", "arctic", "lava", "contrast", "hotcold", "medical"]
+        // Map acol to dynamic palette names
+        let palettes = getAvailablePalettes()
         let idx = Int(acol)
         if idx >= 0 && idx < palettes.count {
             setPalette(palettes[idx])
         }
     }
 
+    @objc public func getAvailablePalettes() -> [String] {
+        #if FLIR_ENABLED
+        // We use a dummy thermal image to access palette manager if no streamer exists,
+        // but typically PaletteManager.getDefaultPalettes() might be static or available via streamer
+        if let streamer = streamer {
+            var names: [String] = []
+            streamer.withThermalImage { img in
+                names = img.paletteManager.getDefaultPalettes().map { $0.name }
+            }
+            if !names.isEmpty { return names }
+        }
+        
+        // Fallback: Try to get from a temporary thermal image if possible, 
+        // but FLIR SDK often requires a valid image. 
+        // For now, return a standard list if we can't get it dynamically, 
+        // or try to find a static way.
+        #endif
+        return ["iron", "rainbow", "grayscale", "arctic", "lava", "contrast", "hotcold", "medical"]
+    }
+
+    @objc public func generatePaletteIcons() -> [[String: String]] {
+        var results: [[String: String]] = []
+        #if FLIR_ENABLED
+        guard let streamer = streamer else { return [] }
+        
+        let fileManager = FileManager.default
+        let cacheDir = fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first!
+        let paletteDir = cacheDir.appendingPathComponent("flir_palettes")
+        
+        if !fileManager.fileExists(atPath: paletteDir.path) {
+            try? fileManager.createDirectory(at: paletteDir, withIntermediateDirectories: true)
+        }
+
+        streamer.withThermalImage { thermalImage in
+            let palettes = thermalImage.paletteManager.getDefaultPalettes()
+            for palette in palettes {
+                let iconURL = paletteDir.appendingPathComponent("\(palette.name.lowercased()).png")
+                if !fileManager.fileExists(atPath: iconURL.path) {
+                    // Assuming palette.icon exists (common in FLIR SDK)
+                    if let icon = palette.icon {
+                        if let data = icon.pngData() {
+                            try? data.write(to: iconURL)
+                        }
+                    }
+                }
+                results.append([
+                    "name": palette.name,
+                    "uri": fileManager.fileExists(atPath: iconURL.path) ? iconURL.absoluteString : ""
+                ])
+            }
+        }
+        #endif
+        return results
+    }
+
+    @objc public func getPalettesWithIcons() -> [[String: String]] {
+        return generatePaletteIcons()
+    }
+
     @objc public func captureRadiometricSnapshot(_ path: String) {
         self.pendingSnapshotPath = path
         NSLog("[FlirManager] Pending radiometric snapshot: \(path)")

package/ios/Flir/src/FlirModule.m

@@ -466,6 +466,30 @@ RCT_EXPORT_METHOD(isBatteryCharging : (RCTPromiseResolveBlock)
   });
 }
 
+RCT_EXPORT_METHOD(getAvailablePalettes : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    id manager = flir_manager_shared();
+    NSArray *palettes = @[];
+    if (manager && [manager respondsToSelector:sel_registerName("getAvailablePalettes")]) {
+      palettes = ((NSArray * (*)(id, SEL)) objc_msgSend)(manager, sel_registerName("getAvailablePalettes"));
+    }
+    if (resolve) resolve(palettes);
+  });
+}
+
+RCT_EXPORT_METHOD(getPalettesWithIcons : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    id manager = flir_manager_shared();
+    NSArray *palettes = @[];
+    if (manager && [manager respondsToSelector:sel_registerName("getPalettesWithIcons")]) {
+      palettes = ((NSArray * (*)(id, SEL)) objc_msgSend)(manager, sel_registerName("getPalettesWithIcons"));
+    }
+    if (resolve) resolve(palettes);
+  });
+}
+
 RCT_EXPORT_METHOD(setPreferSdkRotation : (BOOL)prefer resolver : (
     RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
   dispatch_async(dispatch_get_main_queue(), ^{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilabs-flir",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "FLIR Thermal SDK for React Native - iOS & Android (bundled at compile time via postinstall)",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -55,9 +55,9 @@
     "adm-zip": "^0.5.10"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
     "@types/react": "*",
-    "@types/react-native": "*"
+    "@types/react-native": "*",
+    "typescript": "^5.0.0"
   },
   "react-native": {
     "ios": {

package/src/index.d.ts

@@ -54,6 +54,12 @@ export interface FlirModuleAPI {
     stopFlir(): Promise<boolean>;
     getDiscoveredDevices(): Promise<FlirDevice[]>;
     
+    // Palette & Imaging APIs
+    getAvailablePalettes(): Promise<string[]>;
+    getPalettesWithIcons(): Promise<{ name: string; uri: string }[]>;
+    setPalette(name: string): Promise<boolean>;
+    captureRadiometricSnapshot(path: string): Promise<boolean>;
+
     // Debug APIs
     initializeSDK(): Promise<SDKInitResult>;
     getDebugInfo(): Promise<FlirDebugInfo>;