ilabs-flir 2.3.8 → 2.3.11

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

@@ -8,6 +8,7 @@ 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.ImageBuffer;
 import com.flir.thermalsdk.image.Palette;
 import com.flir.thermalsdk.image.PaletteManager;
 import com.flir.thermalsdk.image.Point;
@@ -22,12 +23,15 @@ import com.flir.thermalsdk.live.connectivity.ConnectionStatusListener;
 import com.flir.thermalsdk.live.discovery.DiscoveredCamera;
 import com.flir.thermalsdk.live.discovery.DiscoveryEventListener;
 import com.flir.thermalsdk.live.discovery.DiscoveryFactory;
+import com.flir.thermalsdk.androidsdk.live.connectivity.SdkWifiConnectionHelper;
 import com.flir.thermalsdk.live.streaming.Stream;
 import com.flir.thermalsdk.live.streaming.ThermalStreamer;
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -50,6 +54,7 @@ public class FlirSdkManager {
     private ThermalStreamer streamer;
     private Stream activeStream;
     private final List<Identity> discoveredDevices = Collections.synchronizedList(new ArrayList<>());
+    private final Map<String, DiscoveredCamera> discoveredCameras = Collections.synchronizedMap(new HashMap<>());
     private volatile Bitmap latestBitmap;
     private volatile String currentPaletteName = "WhiteHot";
     private final AtomicBoolean isProcessingFrame = new AtomicBoolean(false);
@@ -151,25 +156,19 @@ public class FlirSdkManager {
 
     public void stopScan() {
         if (!isScanning) return;
-        
-        // Use a temporary flag to prevent concurrent stop calls
         isScanning = false;
-        
-        executor.execute(() -> {
-            try {
-                Log.d(TAG, "Stopping discovery...");
-                DiscoveryFactory.getInstance().stop(
-                        CommunicationInterface.EMULATOR,
-                        CommunicationInterface.USB,
-                        CommunicationInterface.NETWORK,
-                        CommunicationInterface.FLIR_ONE_WIRELESS);
-                Log.d(TAG, "Discovery stopped successfully");
-            } catch (Exception e) {
-                // This is where the 'Receiver not registered' usually happens in SDK internals.
-                // We catch it silently as it means the SDK already cleaned up or is in a weird state.
-                Log.w(TAG, "Stop scan warning (internal SDK): " + e.getMessage());
-            }
-        });
+        executor.execute(this::stopScanInternal);
+    }
+
+    private void stopScanInternal() {
+        try {
+            Log.d(TAG, "Stopping discovery...");
+            // Use zero-arg stop() as seen in official samples to stop all scanners
+            DiscoveryFactory.getInstance().stop();
+            Log.d(TAG, "Discovery stopped successfully");
+        } catch (Exception e) {
+            Log.w(TAG, "Stop scan warning (internal SDK): " + e.getMessage());
+        }
     }
 
     public List<Identity> getDiscoveredDevices() {
@@ -198,62 +197,92 @@ public class FlirSdkManager {
                     camera = null;
                 }
 
-                Log.d(TAG, "Connecting to: " + identity.deviceId);
-                camera = new Camera();
-
-                // ── Authenticate for NETWORK/WIRELESS cameras (required by FLIR SDK) ──
-                // Matches the official NetworkCamera sample app pattern.
-                // The FLIR One Edge Pro is a network/wireless camera and will reject
-                // connections without prior authentication + trust approval.
-                if (identity.communicationInterface == CommunicationInterface.NETWORK || 
-                    identity.communicationInterface == CommunicationInterface.FLIR_ONE_WIRELESS) {
-                    Log.d(TAG, "Network/Wireless 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();
+                // ── FLIR ONE WIRELESS (WiFi) Connection ──
+                // Matches the official FlirOneWireless sample. We must connect to the
+                // camera's WiFi Access Point before calling camera.connect().
+                if (identity.communicationInterface == CommunicationInterface.FLIR_ONE_WIRELESS) {
+                    DiscoveredCamera dc = getDiscoveredCamera(identity.deviceId);
+                    if (dc != null && dc.cameraDetails != null) {
+                        String ssid = dc.cameraDetails.ssid;
+                        Log.d(TAG, "Establishing WiFi connection to: " + ssid);
+                        
+                        if (!SdkWifiConnectionHelper.isConnectedToNetwork(context, ssid)) {
+                            // This is a blocking-style wrapper for simplicity in the executor thread
+                            final AtomicBoolean wifiDone = new AtomicBoolean(false);
+                            final AtomicBoolean wifiSuccess = new AtomicBoolean(false);
+                            
+                            SdkWifiConnectionHelper.connectToWifiWithoutCode(context, dc.cameraDetails, status -> {
+                                if (status.status == SdkWifiConnectionHelper.ConInfo.CONNECTED) {
+                                    wifiSuccess.set(true);
+                                    wifiDone.set(true);
+                                } else if (status.status == SdkWifiConnectionHelper.ConInfo.ERROR) {
+                                    wifiSuccess.set(false);
+                                    wifiDone.set(true);
+                                }
+                            });
+                            
+                            // Wait for WiFi connection (max 15 seconds)
+                            int waitLoops = 0;
+                            while (!wifiDone.get() && waitLoops < 30) {
+                                try { Thread.sleep(500); } catch (Exception ignored) {}
+                                waitLoops++;
+                            }
+                            
+                            if (!wifiSuccess.get()) {
+                                notifyError("Failed to connect to camera WiFi: " + ssid);
+                                return;
+                            }
+                        }
                     }
+                }
 
+                // ── NETWORK Authentication (Required for A/T-series, NOT Wireless) ──
+                if (identity.communicationInterface == CommunicationInterface.NETWORK) {
+                    Log.d(TAG, "Authenticating with network camera: " + identity.deviceId);
+                    
+                    if (isScanning) {
+                        isScanning = false;
+                        stopScanInternal();
+                        try { Thread.sleep(500); } catch (Exception ignored) {}
+                    }
+                    
+                    camera = new Camera();
+                    String authName = "ThermalCameraFx";
                     AuthenticationResponse response;
                     int attempts = 0;
-                    final int MAX_AUTH_ATTEMPTS = 30; // 30 seconds max wait
+                    final int MAX_AUTH_ATTEMPTS = 3;
+                    
                     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.");
+                        response = camera.authenticate(identity, authName, 41 * 1000);
+                        if (response.authenticationStatus == AuthenticationResponse.AuthenticationStatus.APPROVED) {
+                            break;
+                        } else if (response.authenticationStatus == AuthenticationResponse.AuthenticationStatus.REJECTED) {
+                            notifyError("Authentication rejected by camera");
+                            return;
+                        }
+                    } while (response.authenticationStatus == AuthenticationResponse.AuthenticationStatus.PENDING && attempts < MAX_AUTH_ATTEMPTS);
+
+                    if (response.authenticationStatus != AuthenticationResponse.AuthenticationStatus.APPROVED) {
+                        notifyError("Authentication failed: " + response.authenticationStatus.name());
                         return;
                     }
-                    Log.d(TAG, "Authentication approved");
+                } else {
+                    // For all other types, stop scan if still running
+                    if (isScanning) {
+                        isScanning = false;
+                        stopScanInternal();
+                        try { Thread.sleep(300); } catch (Exception ignored) {}
+                    }
+                    camera = identity.camera;
+                    if (camera == null) {
+                        camera = new Camera();
+                    }
                 }
 
+                Log.d(TAG, "Calling camera.connect() for " + identity.deviceId);
                 camera.connect(identity, connectionStatusListener, new ConnectParameters());
-                Log.d(TAG, "Connected to: " + identity.deviceId);
+                Log.d(TAG, "camera.connect() returned for " + identity.deviceId + ". isConnected=" + camera.isConnected());
 
                 if (listener != null) {
                     listener.onConnected(identity);
@@ -263,7 +292,7 @@ public class FlirSdkManager {
                 startStreamInternal();
 
             } catch (Exception e) {
-                Log.e(TAG, "Connection failed", e);
+                Log.e(TAG, "Connection failed for " + identity.deviceId, e);
                 camera = null;
                 notifyError("Connection failed: " + e.getMessage());
             }
@@ -294,6 +323,10 @@ public class FlirSdkManager {
         return camera != null;
     }
 
+    private DiscoveredCamera getDiscoveredCamera(String deviceId) {
+        return discoveredCameras.get(deviceId);
+    }
+
     // ==================== STREAMING ====================
 
     public void startStream() {
@@ -316,18 +349,50 @@ public class FlirSdkManager {
         }
 
         try {
+            // RETRY MECHANISM: For Network/Wireless cameras, the connection might take 
+            // a few hundred milliseconds to stabilize at the native level even after 
+            // camera.connect() returns. We retry for up to 3 seconds.
+            int retries = 0;
+            final int MAX_RETRIES = 15; // 15 * 200ms = 3 seconds
+            while (!camera.isConnected() && retries < MAX_RETRIES) {
+                try {
+                    Thread.sleep(200);
+                } catch (InterruptedException ignored) {}
+                retries++;
+                if (retries % 5 == 0) {
+                    Log.d(TAG, "Waiting for camera connection state to stabilize... (attempt " + retries + ")");
+                }
+            }
+
             if (!camera.isConnected()) {
-                Log.e(TAG, "Camera not connected, cannot start stream");
+                Log.e(TAG, "Camera failed to report connected state after " + (retries * 200) + "ms");
                 notifyError("Camera not connected");
                 return;
             }
 
-            List<Stream> streams = camera.getStreams();
+            Log.d(TAG, "Camera connected state confirmed after " + (retries * 200) + "ms");
+
+            // RETRY MECHANISM for getStreams: Sometimes streams are not immediately available
+            List<Stream> streams = null;
+            retries = 0;
+            while (retries < 10) { // 10 * 200ms = 2 seconds
+                streams = camera.getStreams();
+                if (streams != null && !streams.isEmpty()) {
+                    break;
+                }
+                try {
+                    Thread.sleep(200);
+                } catch (InterruptedException ignored) {}
+                retries++;
+            }
+
             if (streams == null || streams.isEmpty()) {
                 notifyError("No streams available");
                 return;
             }
 
+            Log.d(TAG, "Streams found: " + streams.size() + " (after " + (retries * 200) + "ms)");
+
             // Find thermal stream or use first
             Stream thermalStream = null;
             for (Stream stream : streams) {
@@ -362,32 +427,37 @@ public class FlirSdkManager {
                                         // 1. Apply Palette
                                         if (paletteToApply != null) {
                                             try {
-                                                Palette palette = null;
-                                                // Standard FLIR palette list from samples
-                                                String[] paletteNames = {"Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel"};
+                                                List<Palette> sdkPalettes = PaletteManager.getDefaultPalettes();
                                                 
-                                                for (String name : paletteNames) {
-                                                    if (name.equalsIgnoreCase(paletteToApply)) {
-                                                        try {
-                                                            // 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;
-                                                                }
+                                                if (paletteToApply.equalsIgnoreCase("Gray") || paletteToApply.equalsIgnoreCase("grayscale")) {
+                                                    // User wants Gray - map to WhiteHot which is the SDK's standard grayscale
+                                                    for (Palette p : sdkPalettes) {
+                                                        if (p.name.equalsIgnoreCase("WhiteHot") || p.name.equalsIgnoreCase("White hot")) {
+                                                            thermalImage.setPalette(p);
+                                                            break;
+                                                        }
+                                                    }
+                                                } else {
+                                                    Palette palette = null;
+                                                    for (Palette p : sdkPalettes) {
+                                                        if (p.name.equalsIgnoreCase(paletteToApply)) {
+                                                            palette = p;
+                                                            break;
+                                                        }
+                                                    }
+                                                    
+                                                    if (palette != null) {
+                                                        thermalImage.setPalette(palette);
+                                                    } else if (paletteToApply.equalsIgnoreCase("Wheel")) {
+                                                        // Fallback for Wheel if not found - some SDKs use different names
+                                                        for (Palette p : sdkPalettes) {
+                                                            if (p.name.contains("Wheel") || p.name.contains("ColorWheel") || p.name.contains("Rainbow")) {
+                                                                thermalImage.setPalette(p);
+                                                                break;
                                                             }
-                                                        } catch (Throwable t) {
-                                                            Log.w(TAG, "Dynamic palette lookup failed, using fallback mechanism");
                                                         }
-                                                        break;
                                                     }
                                                 }
-                                                
-                                                if (palette != null) {
-                                                    thermalImage.setPalette(palette);
-                                                }
                                             } catch (Throwable t) {
                                                 Log.e(TAG, "Failed to apply palette: " + paletteToApply, t);
                                             }
@@ -396,8 +466,9 @@ public class FlirSdkManager {
                                         // 2. Save Radiometric Snapshot if requested
                                         if (snapshotPath != null) {
                                             try {
+                                                Log.i(TAG, "[SNAPSHOT] Attempting to save radiometric snapshot: " + snapshotPath);
                                                 thermalImage.saveAs(snapshotPath);
-                                                Log.i(TAG, "Radiometric snapshot saved to: " + snapshotPath);
+                                                Log.i(TAG, "[SNAPSHOT] ✅ Success: Radiometric snapshot saved");
                                                 if (snapshotCallback != null) {
                                                     snapshotCallback.onSnapshotSaved(snapshotPath);
                                                 }
@@ -410,12 +481,22 @@ public class FlirSdkManager {
                                         }
 
                                         // 3. Generate Bitmap for display
-                                        Bitmap bitmap = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
-                                        if (bitmap != null) {
-                                            latestBitmap = bitmap;
-                                            if (listener != null) {
-                                                listener.onFrame(bitmap);
+                                        // We use streamer.getImage() to get the rendered image with palette applied.
+                                        try {
+                                            Bitmap newBitmap = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
+                                            if (newBitmap != null) {
+                                                Bitmap oldBitmap = latestBitmap;
+                                                latestBitmap = newBitmap;
+                                                if (listener != null) {
+                                                    listener.onFrame(newBitmap);
+                                                }
+                                                // Recycle old bitmap to prevent memory leak
+                                                if (oldBitmap != null && oldBitmap != newBitmap) {
+                                                    oldBitmap.recycle();
+                                                }
                                             }
+                                        } catch (Exception e) {
+                                            Log.e(TAG, "Bitmap creation failed", e);
                                         }
                                     });
                                 }
@@ -514,6 +595,8 @@ public class FlirSdkManager {
             Identity identity = discoveredCamera.getIdentity();
             Log.d(TAG, "Device found: " + identity.deviceId);
 
+            discoveredCameras.put(identity.deviceId, discoveredCamera);
+
             synchronized (discoveredDevices) {
                 boolean exists = false;
                 for (Identity d : discoveredDevices) {
@@ -536,6 +619,7 @@ public class FlirSdkManager {
         @Override
         public void onCameraLost(Identity identity) {
             Log.d(TAG, "Device lost: " + identity.deviceId);
+            discoveredCameras.remove(identity.deviceId);
             synchronized (discoveredDevices) {
                 discoveredDevices.removeIf(d -> d.deviceId.equals(identity.deviceId));
             }

package/ios/Flir/src/FlirManager.swift

@@ -162,7 +162,13 @@ import ThermalSDK
             disconnect()
         }
         
-        // Connect on background thread (matches sample app)
+        // Stop discovery before connecting to free up SDK resources
+        // This prevents resource contention in the native SDK layer.
+        if discovery != nil {
+            discovery?.stop()
+        }
+        
+        // Connect on background thread (matches sample app pattern)
         DispatchQueue.global().async { [weak self] in
             guard let self = self else { return }
             
@@ -191,7 +197,8 @@ import ThermalSDK
                 NSLog("[FlirManager] Network camera detected — authenticating...")
                 
                 // Use UUID-based persistent certificate name (matches FLIR sample).
-                // The camera has a bug where re-auth with a different name conflicts.
+                // The camera has a bug where re-auth with a different name can conflict,
+                // so we generate a UUID once and persist it in UserDefaults.
                 let certName = self.getPersistentCertificateName()
                 NSLog("[FlirManager] Using certificate name: \(certName)")
                 
@@ -435,7 +442,7 @@ import ThermalSDK
                 // Compiler says it is NOT optional here, so direct assignment.
                 let value = spot.getValue()
                 result = value.value
-
+                
                 try? measurements.remove(spot)
             }
         }
@@ -445,8 +452,6 @@ import ThermalSDK
 #endif
     }
     
-
-    
     @objc public func getTemperatureAtNormalized(_ nx: Double, y: Double) -> Double {
 #if FLIR_ENABLED
         guard let streamer = streamer, _isStreaming else { return Double.nan }
@@ -458,10 +463,10 @@ import ThermalSDK
             
             // Map normalized (0.0 - 1.0) to actual sensor pixels
             let cx = max(0, min(Int(w) - 1, Int(nx * w)))
-            let cy = max(0, min(Int(h) - 1, Int(y * h)))
+            let cy_fixed = max(0, min(Int(h) - 1, Int(y * h)))
             
             if let measurements = thermalImage.measurements,
-               let spot = try? measurements.addSpot(CGPoint(x: cx, y: cy)) {
+               let spot = try? measurements.addSpot(CGPoint(x: cx, y: cy_fixed)) {
                 result = spot.getValue().value
                 try? measurements.remove(spot)
             }
@@ -503,8 +508,6 @@ import ThermalSDK
 
     // MARK: - Battery (stub - not needed per user)
     
-    // MARK: - Battery (stub - not needed per user)
-    
     @objc public func getBatteryLevel() -> Int { return -1 }
     @objc public func isBatteryCharging() -> Bool { return false }
     
@@ -531,21 +534,16 @@ import ThermalSDK
     }
 
     @objc public func getAvailablePalettes() -> [String] {
-        return ["Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel"]
+        return ["WhiteHot", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel"]
     }
 
     @objc public func generatePaletteIcons() -> [[String: String]] {
         let paletteNames = getAvailablePalettes()
-        let fileManager = FileManager.default
-        let cacheDir = fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first!
-        let paletteDir = cacheDir.appendingPathComponent("flir_palettes")
-        
         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 : ""
+                "uri": "" // No URI - rely on local assets if any
             ])
         }
         return results
@@ -604,20 +602,15 @@ import ThermalSDK
         return newName
     }
     
-#if FLIR_ENABLED
-    private func interfaceName(_ iface: FLIRCommunicationInterface) -> String {
-        if iface.contains(.lightning) { return "LIGHTNING" }
-        if iface.contains(.network) { return "NETWORK" }
-        if iface.contains(.flirOneWireless) { return "WIRELESS" }
-        if iface.contains(.emulator) { return "EMULATOR" }
+    private func interfaceName(_ iface: Int) -> String {
+        // Placeholder for interface name mapping
         return "UNKNOWN"
     }
-#endif
 }
 
+#if FLIR_ENABLED
 // MARK: - Discovery Delegate
 
-#if FLIR_ENABLED
 extension FlirManager: FLIRDiscoveryEventDelegate {
     public func cameraDiscovered(_ camera: FLIRDiscoveredCamera) {
         let identity = camera.identity
@@ -632,7 +625,7 @@ extension FlirManager: FLIRDiscoveryEventDelegate {
         let deviceInfo = FlirDeviceInfo(
             deviceId: deviceId,
             name: camera.displayName ?? deviceId,
-            communicationType: interfaceName(identity.communicationInterface()),
+            communicationType: interfaceName(Int(identity.communicationInterface().rawValue)),
             isEmulator: identity.communicationInterface() == .emulator
         )
         
@@ -653,7 +646,7 @@ extension FlirManager: FLIRDiscoveryEventDelegate {
     }
     
     public func discoveryFinished(_ iface: FLIRCommunicationInterface) {
-        NSLog("[FlirManager] Discovery finished: \(iface)")
+        NSLog("[FlirManager] Discovery finished: \(iface.rawValue)")
     }
     
     public func cameraLost(_ cameraIdentity: FLIRIdentity) {
@@ -669,11 +662,9 @@ extension FlirManager: FLIRDiscoveryEventDelegate {
         }
     }
 }
-#endif
 
 // MARK: - Camera Delegate
 
-#if FLIR_ENABLED
 extension FlirManager: FLIRDataReceivedDelegate {
     public func onDisconnected(_ camera: FLIRCamera, withError error: Error?) {
         NSLog("[FlirManager] Camera disconnected: \(error?.localizedDescription ?? "clean")")
@@ -690,11 +681,9 @@ extension FlirManager: FLIRDataReceivedDelegate {
         }
     }
 }
-#endif
 
 // MARK: - Stream Delegate
 
-#if FLIR_ENABLED
 extension FlirManager: FLIRStreamDelegate {
     public func onError(_ error: Error) {
         NSLog("[FlirManager] Stream error: \(error)")
@@ -702,13 +691,10 @@ extension FlirManager: FLIRStreamDelegate {
     }
     
     public func onImageReceived() {
-        NSLog("[FLIR-TRACE 1️⃣] onImageReceived called on SDK thread")
-        
         // Process frame on dedicated render queue (matches sample app pattern)
         // This prevents blocking the SDK callback thread and main thread
         // Guard to skip frame if already processing (prevents backpressure/latency)
         guard !_isProcessingFrame else {
-            NSLog("[FLIR-TRACE ⏩] Skipping frame (already processing)")
             return
         }
         
@@ -716,12 +702,9 @@ extension FlirManager: FLIRStreamDelegate {
         renderQueue.async { [weak self] in
             defer { self?._isProcessingFrame = false }
             guard let self = self, self._isStreaming, let streamer = self.streamer else {
-                NSLog("[FLIR-TRACE ❌] No self, streamer or not streaming in renderQueue")
                 return
             }
             
-            NSLog("[FLIR-TRACE 2️⃣] Processing on renderQueue")
-            
             objc_sync_enter(self.stateLock)
             let currentStreamer = self.streamer
             let streaming = self._isStreaming
@@ -740,7 +723,26 @@ extension FlirManager: FLIRStreamDelegate {
                 
                 streamer.withThermalImage { thermalImage in
                     // 1. Apply Palette
-                    if let palette = thermalImage.paletteManager.getDefaultPalettes().first(where: { $0.name.lowercased() == paletteToApply.lowercased() }) {
+                    let sdkPalettes = thermalImage.paletteManager.getDefaultPalettes()
+                    var targetPalette: FLIRPalette? = nil
+                    
+                    if paletteToApply.lowercased() == "gray" || paletteToApply.lowercased() == "grayscale" {
+                        // Map Gray to WhiteHot (standard SDK name)
+                        targetPalette = sdkPalettes.first(where: { 
+                            $0.name.lowercased() == "whitehot" || $0.name.lowercased() == "white hot" 
+                        })
+                    } else {
+                        targetPalette = sdkPalettes.first(where: { $0.name.lowercased() == paletteToApply.lowercased() })
+                        
+                        // Fallback for Wheel
+                        if targetPalette == nil && paletteToApply.lowercased() == "wheel" {
+                            targetPalette = sdkPalettes.first(where: {
+                                $0.name.contains("Wheel") || $0.name.contains("ColorWheel") || $0.name.contains("Rainbow")
+                            })
+                        }
+                    }
+                    
+                    if let palette = targetPalette {
                         thermalImage.palette = palette
                     }
 
@@ -753,29 +755,23 @@ extension FlirManager: FLIRStreamDelegate {
                             NSLog("[FlirManager] Failed to save radiometric snapshot: \(error)")
                         }
                     }
+
+                    // 3. Generate UIImage for display
+                    // Grab the image while the thermal image is locked to ensure settings are applied
+                    if let image = streamer.getImage() {
+                        self._latestImage = image
+                        let width = Int(image.size.width)
+                        let height = Int(image.size.height)
+                        
+                        DispatchQueue.main.async { [weak self] in
+                            self?.delegate?.onFrameReceived(image, width: width, height: height)
+                        }
+                    }
                 }
-                
-                NSLog("[FLIR-TRACE 3️⃣] Streamer updated successfully")
             } catch {
-                NSLog("[FLIR-TRACE ❌] Streamer update failed: \(error)")
+                NSLog("[FlirManager] Streamer update failed: \(error)")
                 return
             }
-            
-            guard let image = streamer.getImage() else {
-                NSLog("[FLIR-TRACE ❌] streamer.getImage() returned nil")
-                return
-            }
-            
-            NSLog("[FLIR-TRACE 4️⃣] Got image from streamer: \(image.size.width)x\(image.size.height)")
-            
-            self._latestImage = image
-            let width = Int(image.size.width)
-            let height = Int(image.size.height)
-            
-            DispatchQueue.main.async { [weak self] in
-                NSLog("[FLIR-TRACE 5️⃣] Dispatching to delegate.onFrameReceived on main thread")
-                self?.delegate?.onFrameReceived(image, width: width, height: height)
-            }
         }
     }
 }

package/ios/Flir/src/FlirPreviewView.m

@@ -72,9 +72,6 @@
 }
 
 - (void)updateWithImage:(UIImage *)image {
-  if (!image)
-    return;
-
   dispatch_async(dispatch_get_main_queue(), ^{
     self.imageView.image = image;
   });