ilabs-flir 2.3.6 → 2.3.8

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

@@ -30,6 +30,13 @@ object FlirManager {
     private val lastEmitMs = AtomicLong(0)
     private val minEmitIntervalMs = 100L // ~10 fps max for RN events
     
+    // Cached palette list to avoid repeated JNI calls (especially if linkage is unstable)
+    private var cachedPalettes: List<*>? = null
+    private var cachedPaletteNames: List<String>? = null
+    
+    // Cached reflection for performance
+    private var coolField: java.lang.reflect.Field? = null
+    
     // State
     private var isInitialized = false
     private var isScanning = false
@@ -118,15 +125,6 @@ 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()
     }
     
     /**
@@ -446,60 +444,32 @@ object FlirManager {
     fun forceEmulatorMode(type: String = "FLIR_ONE_EDGE") { startDiscovery() }
     fun setPreferredEmulatorType(type: String) { }
     fun updateAcol(value: Float) {
-        Log.d(TAG, "updateAcol: $value")
-        // Use reflection to update ilabs.libs.io.data.Var.cool to avoid circular dependency
+        // Log.v(TAG, "updateAcol: $value")
         try {
-            val varClass = Class.forName("ilabs.libs.io.data.Var")
-            val coolField = varClass.getField("cool")
+            if (coolField == null) {
+                val varClass = Class.forName("ilabs.libs.io.data.Var")
+                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 using the official SDK palette list
-            var sdkPalettes: List<*>? = null
-            try {
-                sdkPalettes = PaletteManager.getDefaultPalettes()
-            } catch (t: Throwable) {
-                try {
-                    val altClazz = Class.forName("com.flir.thermalsdk.image.palettes.PaletteManager")
-                    val method = altClazz.getMethod("getDefaultPalettes")
-                    sdkPalettes = method.invoke(null) as? List<*>
-                } catch (t2: Throwable) {
-                    Log.w(TAG, "Palette discovery failed in updateAcol", t2)
-                }
-            }
+            coolField?.set(null, shaderIdx)
 
-            val currentPalettes = sdkPalettes
-            if (currentPalettes != null && currentPalettes.isNotEmpty()) {
-                val paletteNames = currentPalettes.map { p -> 
-                    try {
-                        p?.let { it::class.java.getMethod("getName").invoke(it) as? String } ?: p?.toString() ?: ""
-                    } catch (e: Exception) { 
-                        p?.toString() ?: ""
-                    }
-                }
-                Log.d(TAG, "True FLIR Palettes: $paletteNames")
-                
-                val maxEff = currentPalettes.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)
-            }
+            // Standard FLIR palette list
+            val paletteNames = listOf("Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel")
+            val maxEff = paletteNames.size
+            val paletteIdx = rawIdx % maxEff
+            val safeIdx = if (paletteIdx < 0) paletteIdx + maxEff else paletteIdx
+            
+            val targetPaletteName = paletteNames[safeIdx]
+            sdkManager?.setPalette(targetPaletteName)
             
         } catch (e: Throwable) {
-            Log.w(TAG, "Could not update Var.cool via reflection: ${e.message}")
+            Log.w(TAG, "updateAcol reflection failed: ${e.message}")
         }
     }
 
@@ -509,79 +479,23 @@ object FlirManager {
     fun generatePaletteIcons(context: Context): List<Map<String, String>> {
         val results = mutableListOf<Map<String, String>>()
         try {
-            var rawPalettes: List<*>? = null
-            try {
-                rawPalettes = PaletteManager.getDefaultPalettes()
-            } catch (t: Throwable) {
-                Log.e(TAG, "PaletteManager.getDefaultPalettes() failed in icon generation", t)
-                try {
-                    val altClazz = Class.forName("com.flir.thermalsdk.image.palettes.PaletteManager")
-                    val method = altClazz.getMethod("getDefaultPalettes")
-                    rawPalettes = method.invoke(null) as? List<*>
-                } catch (t2: Throwable) {
-                    Log.e(TAG, "Alternative package search also failed in icon generation", t2)
-                }
-            }
-
-            val currentPalettes = rawPalettes
-            if (currentPalettes == null) {
-                Log.e(TAG, "Failed to retrieve any palettes from SDK")
-                return emptyList()
-            }
-
-            val palettes = currentPalettes.toMutableList()
+            // Standard FLIR palette list from samples
+            val paletteNames = listOf("Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel")
             
-            // Reorder: Move WhiteHot/Gray to the front
-            val grayIdx = palettes.indexOfFirst { p ->
-                val name = try {
-                    p?.let { it::class.java.getMethod("getName").invoke(it) as? String } ?: p?.toString() ?: ""
-                } catch (e: Exception) { p?.toString() ?: "" }
-                
-                name.equals("WhiteHot", ignoreCase = true) || name.equals("Gray", ignoreCase = true) || 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 name = try {
-                    palette?.let { it::class.java.getMethod("getName").invoke(it) as? String } ?: palette?.toString() ?: "unknown"
-                } catch (e: Exception) { palette?.toString() ?: "unknown" }
-
+            for (name in paletteNames) {
                 val iconFile = File(dir, "${name.lowercase()}.png")
-                if (!iconFile.exists()) {
-                    try {
-                        // Common method names for palette preview in FLIR SDK: getBitmap(), getIcon()
-                        val bitmap = try {
-                            val m = palette?.let { it::class.java.getMethod("getBitmap") }
-                            m?.invoke(palette) as? Bitmap
-                        } catch (e: Exception) {
-                            try {
-                                val m = palette?.let { it::class.java.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 $name: ${e.message}")
-                    }
-                }
+                // Note: We'll rely on the app to provide these icons or they will be generated by the SDK if possible.
+                // For now, we return the names and the cache path.
                 results.add(mapOf(
                     "name" to name,
                     "uri" to if (iconFile.exists()) "file://${iconFile.absolutePath}" else ""
                 ))
             }
         } catch (t: Throwable) {
-            Log.e(TAG, "Palette icon generation error", t)
+            Log.e(TAG, "Palette icon list generation error", t)
         }
         return results
     }

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

@@ -101,15 +101,6 @@ public class FlirSdkManager {
         if (isInitialized)
             return;
         try {
-        try {
-            // Explicitly load the native library to ensure JNI methods are linked
-            try {
-                System.loadLibrary("atlas_native");
-                Log.i(TAG, "Successfully loaded atlas_native library manually");
-            } catch (UnsatisfiedLinkError e) {
-                Log.w(TAG, "System.loadLibrary(atlas_native) failed (might be loaded by SDK): " + e.getMessage());
-            }
-
             ThermalSdkAndroid.init(context);
             
             // Small delay to ensure JNI linkage is stable
@@ -117,12 +108,9 @@ public class FlirSdkManager {
             
             isInitialized = true;
             Log.i(TAG, "FLIR SDK initialized successfully. Arch: " + System.getProperty("os.arch"));
+            Log.d(TAG, "SDK initialized");
         } catch (Throwable e) {
             Log.e(TAG, "Critical failure during FLIR SDK initialization", e);
-        }
-            Log.d(TAG, "SDK initialized");
-        } catch (Exception e) {
-            Log.e(TAG, "SDK init failed", e);
             notifyError("SDK init failed: " + e.getMessage());
         }
     }
@@ -375,36 +363,25 @@ public class FlirSdkManager {
                                         if (paletteToApply != null) {
                                             try {
                                                 Palette palette = null;
-                                                // 1. Try to get default palettes list safely
-                                                List<?> sdkPalettes = null;
-                                                try {
-                                                    sdkPalettes = PaletteManager.getDefaultPalettes();
-                                                } catch (Throwable t) {
-                                                    Log.e(TAG, "PaletteManager.getDefaultPalettes() failed (Linkage Error?)", t);
-                                                    // Fallback: Try to use reflection for alternative package if suggested
-                                                    try {
-                                                        Class<?> altClazz = Class.forName("com.flir.thermalsdk.image.palettes.PaletteManager");
-                                                        java.lang.reflect.Method method = altClazz.getMethod("getDefaultPalettes");
-                                                        sdkPalettes = (List<?>) method.invoke(null);
-                                                        Log.i(TAG, "Successfully retrieved palettes using alternative package");
-                                                    } catch (Throwable t2) {
-                                                        Log.e(TAG, "Alternative PaletteManager search also failed", t2);
-                                                    }
-                                                }
-
-                                                if (sdkPalettes != null) {
-                                                    for (Object p : sdkPalettes) {
-                                                        String pName = "";
+                                                // Standard FLIR palette list from samples
+                                                String[] paletteNames = {"Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel"};
+                                                
+                                                for (String name : paletteNames) {
+                                                    if (name.equalsIgnoreCase(paletteToApply)) {
                                                         try {
-                                                            pName = (String) p.getClass().getMethod("getName").invoke(p);
-                                                        } catch (Exception e) {
-                                                            pName = p.toString();
-                                                        }
-
-                                                        if (pName != null && pName.equalsIgnoreCase(paletteToApply)) {
-                                                            palette = (Palette) p;
-                                                            break;
+                                                            // We still need to find the Palette object from the SDK if possible
+                                                            // But we try to do it safely
+                                                            List<Palette> sdkPalettes = PaletteManager.getDefaultPalettes();
+                                                            for (Palette p : sdkPalettes) {
+                                                                if (p.name.equalsIgnoreCase(name)) {
+                                                                    palette = p;
+                                                                    break;
+                                                                }
+                                                            }
+                                                        } catch (Throwable t) {
+                                                            Log.w(TAG, "Dynamic palette lookup failed, using fallback mechanism");
                                                         }
+                                                        break;
                                                     }
                                                 }
                                                 

package/ios/Flir/src/FlirManager.swift

@@ -520,72 +520,34 @@ import ThermalSDK
     }
     
     @objc public func setPaletteFromAcol(_ acol: Float) {
-        // Map acol to dynamic palette names
         let palettes = getAvailablePalettes()
         let idx = Int(acol)
-        if idx >= 0 && idx < palettes.count {
-            setPalette(palettes[idx])
+        let maxEff = palettes.count
+        if maxEff > 0 {
+            let paletteIdx = idx % maxEff
+            let safeIdx = paletteIdx < 0 ? paletteIdx + maxEff : paletteIdx
+            setPalette(palettes[safeIdx])
         }
     }
 
     @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"]
+        return ["Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel"]
     }
 
     @objc public func generatePaletteIcons() -> [[String: String]] {
-        var results: [[String: String]] = []
-        #if FLIR_ENABLED
-        guard let streamer = streamer else { return [] }
-        
+        let paletteNames = getAvailablePalettes()
         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 : ""
-                ])
-            }
+        var results: [[String: String]] = []
+        for name in paletteNames {
+            let iconURL = paletteDir.appendingPathComponent("\(name.lowercased()).png")
+            results.append([
+                "name": name,
+                "uri": fileManager.fileExists(atPath: iconURL.path) ? iconURL.absoluteString : ""
+            ])
         }
-        #endif
         return results
     }
 

package/package.json

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