ilabs-flir 2.3.2 → 2.3.4

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,30 @@ 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 {
+            val palettes = PaletteManager.getDefaultPalettes().map { it.name }.toMutableList()
+            // Move WhiteHot/Gray to the front
+            val grayIdx = palettes.indexOfFirst { 
+                it.equals("WhiteHot", ignoreCase = true) || it.equals("Gray", ignoreCase = true) || it.contains("gray", ignoreCase = true) 
+            }
+            if (grayIdx > 0) {
+                val gray = palettes.removeAt(grayIdx)
+                palettes.add(0, gray)
+            }
+            palettes
+        } catch (t: Throwable) {
+            Log.e(TAG, "Failed to get available palettes from SDK", t)
+            listOf("grayscale", "iron", "rainbow", "arctic", "lava", "contrast", "hotcold", "medical")
+        }
+    }
     
     /**
      * Initialize the FLIR SDK
@@ -102,6 +117,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()
     }
     
     /**
@@ -438,15 +462,85 @@ 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 rawPalettes = PaletteManager.getDefaultPalettes()
+            val palettes = rawPalettes.toMutableList()
+            
+            // Reorder: Move WhiteHot/Gray to the front
+            val grayIdx = palettes.indexOfFirst { 
+                it.name.equals("WhiteHot", ignoreCase = true) || it.name.equals("Gray", ignoreCase = true) || it.name.contains("gray", ignoreCase = true)
+            }
+            if (grayIdx > 0) {
+                val gray = palettes.removeAt(grayIdx)
+                palettes.add(0, gray)
+            }
+
+            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 (t: Throwable) {
+            Log.e(TAG, "Palette icon generation error", t)
+        }
+        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 {

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

@@ -51,7 +51,7 @@ 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 volatile String currentPaletteName = "WhiteHot";
     private final AtomicBoolean isProcessingFrame = new AtomicBoolean(false);
     private boolean useHalfScale = false;
     private String pendingSnapshotPath = null;
@@ -356,13 +356,23 @@ public class FlirSdkManager {
                                     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);
+                                            try {
+                                                Palette palette = null;
+                                                // Try modern way if available (via image's palette manager)
+                                                // Otherwise fallback to static PaletteManager
+                                                List<Palette> sdkPalettes = PaletteManager.getDefaultPalettes();
+                                                for (Palette p : sdkPalettes) {
+                                                    if (p.name.equalsIgnoreCase(paletteToApply)) {
+                                                        palette = p;
+                                                        break;
+                                                    }
+                                                }
+                                                
+                                                if (palette != null) {
+                                                    thermalImage.setPalette(palette);
+                                                }
+                                            } catch (Throwable t) {
+                                                Log.e(TAG, "Failed to apply palette: " + paletteToApply, t);
                                             }
                                         }
 

package/ios/Flir/src/FlirManager.swift

@@ -67,7 +67,7 @@ import ThermalSDK
     private let stateLock = NSObject()
     
     // Palette and Snapshot state
-    private var currentPaletteName: String = "iron"
+    private var currentPaletteName: String = "WhiteHot"
     private var pendingSnapshotPath: String?
     
     // Dedicated render queue for frame processing (matches sample app pattern)
@@ -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,79 @@ 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
+        if let streamer = streamer {
+            var names: [String] = []
+            streamer.withThermalImage { img in
+                var palettes = img.paletteManager.getDefaultPalettes().map { $0.name }
+                // Reorder: Move WhiteHot/Gray to the front
+                if let grayIdx = palettes.firstIndex(where: { $0.lowercased() == "whitehot" || $0.lowercased() == "gray" }) {
+                    let gray = palettes.remove(at: grayIdx)
+                    palettes.insert(gray, at: 0)
+                }
+                names = palettes
+            }
+            if !names.isEmpty { return names }
+        }
+        #endif
+        return ["WhiteHot", "iron", "rainbow", "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
+            var palettes = thermalImage.paletteManager.getDefaultPalettes()
+            
+            // Reorder: Move WhiteHot/Gray to the front
+            if let grayIdx = palettes.firstIndex(where: { $0.name.lowercased() == "whitehot" || $0.name.lowercased() == "gray" }) {
+                let gray = palettes.remove(at: grayIdx)
+                palettes.insert(gray, at: 0)
+            }
+
+            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.2",
+  "version": "2.3.4",
   "description": "FLIR Thermal SDK for React Native - iOS & Android (bundled at compile time via postinstall)",
   "main": "src/index.js",
   "types": "src/index.d.ts",

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>;