ilabs-flir 2.2.2 → 2.2.4

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

@@ -351,7 +351,20 @@ object FlirManager {
         
         override fun onError(message: String) {
             Log.e(TAG, "Error: $message")
-            emitError(message)
+            
+            // Parse error code if present (format: "CODE: message")
+            val parts = message.split(": ", limit = 2)
+            val errorCode = if (parts.size == 2) parts[0] else "FLIR_ERROR"
+            val errorMessage = if (parts.size == 2) parts[1] else message
+            
+            // Auto-disable streaming on critical errors to allow retry
+            if (errorCode.contains("NATIVE") || errorCode.contains("INIT")) {
+                Log.w(TAG, "[Flir-BRIDGE-ERROR] Critical error detected, stopping stream")
+                isStreaming = false
+                stopStream()
+            }
+            
+            emitError(errorCode, errorMessage)
         }
 
         override fun onBatteryUpdated(level: Int, isCharging: Boolean) {
@@ -454,13 +467,21 @@ object FlirManager {
     }
     
     private fun emitError(message: String) {
+        emitError("FLIR_ERROR", message)
+    }
+    
+    private fun emitError(errorCode: String, message: String) {
         val ctx = reactContext ?: return
         try {
             val params = Arguments.createMap().apply {
+                putString("code", errorCode)
                 putString("error", message)
+                putString("message", message) // For backward compatibility
+                putBoolean("canRetry", errorCode.contains("NATIVE") || errorCode.contains("INIT"))
             }
             ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 .emit("FlirError", params)
+            Log.d(TAG, "[Flir-BRIDGE-ERROR] Emitted FlirError: [$errorCode] $message")
         } catch (e: Exception) {
             Log.e(TAG, "Failed to emit error", e)
         }

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

@@ -328,6 +328,19 @@ public class FlirSdkManager {
             return;
         }
 
+        // CRITICAL FIX: Prevent starting stream if previous stream is still active
+        // This prevents race conditions and resource conflicts
+        if (streamer != null || activeStream != null) {
+            Log.w(TAG, "[Flir-STREAMING] Stream already active, stopping first");
+            stopStream();
+            
+            // Wait for cleanup to complete
+            try {
+                Thread.sleep(200);
+            } catch (InterruptedException ignored) {
+            }
+        }
+
         executor.execute(() -> {
             try {
                 // Get available streams
@@ -351,7 +364,46 @@ public class FlirSdkManager {
                 }
 
                 activeStream = thermalStream;
-                streamer = new ThermalStreamer(thermalStream);
+                
+                // CRITICAL FIX: Validate stream before creating ThermalStreamer
+                // The FLIR SDK native library can crash if stream is in invalid state
+                if (!thermalStream.isAvailable()) {
+                    notifyError("Thermal stream not available. Please reconnect device.");
+                    return;
+                }
+                
+                // CRITICAL FIX: Wrap ThermalStreamer creation in try-catch
+                // While native crashes usually bypass Java exception handling,
+                // we can catch:
+                // 1. JNI errors (UnsatisfiedLinkError, Error subclasses)
+                // 2. SDK errors before they reach native code
+                // 3. Resource initialization failures
+                // This won't prevent SIGSEGV/SIGABRT but reduces crash frequency
+                try {
+                    // Small delay to ensure stream and resources are fully initialized
+                    // This prevents race conditions in the native filter chain setup
+                    Thread.sleep(150);
+                    
+                    streamer = new ThermalStreamer(thermalStream);
+                    Log.d(TAG, "[Flir-STREAMING] ThermalStreamer created successfully");
+                } catch (UnsatisfiedLinkError e) {
+                    // JNI library loading error
+                    Log.e(TAG, "[Flir-STREAMING] JNI library error creating ThermalStreamer", e);
+                    notifyError("FLIR_NATIVE_ERROR", "Failed to load native library. Please restart app.");
+                    return;
+                } catch (Exception e) {
+                    // Java exception during initialization
+                    Log.e(TAG, "[Flir-STREAMING] Failed to create ThermalStreamer", e);
+                    notifyError("FLIR_INIT_ERROR", "Failed to initialize thermal camera: " + e.getMessage());
+                    return;
+                } catch (Error e) {
+                    // Catch native errors/crashes from FLIR SDK
+                    // Note: True SIGSEGV crashes will still kill the process,
+                    // but some JNI errors can be caught here
+                    Log.e(TAG, "[Flir-STREAMING] Native error creating ThermalStreamer", e);
+                    notifyError("FLIR_NATIVE_ERROR", "Native error from FLIR device. Please reconnect and retry.");
+                    return;
+                }
 
                 // Start receiving frames using OnReceived and OnRemoteError
                 thermalStream.start(
@@ -419,7 +471,15 @@ public class FlirSdkManager {
             activeStream = null;
         }
 
-        streamer = null;
+        // CRITICAL FIX: Properly cleanup streamer to prevent resource leaks
+        if (streamer != null) {
+            try {
+                // Give streamer time to cleanup before nulling
+                Thread.sleep(50);
+            } catch (InterruptedException ignored) {
+            }
+            streamer = null;
+        }
 
         // Reset frame processing state
         isProcessingFrame = false;
@@ -712,6 +772,17 @@ public class FlirSdkManager {
             listener.onError(message);
         }
     }
+    
+    /**
+     * Notify error with error code for better handling
+     */
+    private void notifyError(String errorCode, String message) {
+        Log.e(TAG, "[" + errorCode + "] " + message);
+        if (listener != null) {
+            // Send both code and message - listener can parse it
+            listener.onError(errorCode + ": " + message);
+        }
+    }
 
     /**
      * Cleanup resources

package/ios/Flir/src/FlirManager.swift

@@ -74,6 +74,9 @@ import ThermalSDK
     // Client lifecycle for discovery/connection ownership
     private var activeClients: Set<String> = []
     private var shutdownWorkItem: DispatchWorkItem? = nil
+    // Discovery & stream watchdogs to detect silent failures/timeouts
+    private var discoveryTimeoutWorkItem: DispatchWorkItem? = nil
+    private var streamWatchdogWorkItem: DispatchWorkItem? = nil
     
     // Battery polling timer (like Android)
     private var batteryPollingTimer: Timer?
@@ -399,6 +402,27 @@ import ThermalSDK
         discovery?.start(interfaces)
         
         emitStateChange("discovering")
+
+        // Cancel any previous discovery timeout and schedule a new one so
+        // the UI doesn't remain stuck when discovery yields no devices.
+        discoveryTimeoutWorkItem?.cancel()
+        let discWork = DispatchWorkItem { [weak self] in
+            guard let self = self else { return }
+            if self.discoveredDevices.isEmpty && self.isScanning {
+                FlirLogger.logError(.discovery, "Discovery timed out with no devices")
+                self.discovery?.stop()
+                self.isScanning = false
+                DispatchQueue.main.async {
+                    // Notify native listeners that discovery finished with no devices
+                    self.delegate?.onDevicesFound(self.discoveredDevices)
+                    // Emit a state change so JS can set noDeviceFound = true
+                    self.emitStateChange("no_device_found")
+                    self.delegate?.onError("Discovery timed out")
+                }
+            }
+        }
+        discoveryTimeoutWorkItem = discWork
+        DispatchQueue.main.asyncAfter(deadline: .now() + 8.0, execute: discWork)
 #else
         FlirLogger.logError(.discovery, "FLIR SDK not available - discovery disabled")
         delegate?.onError("FLIR SDK not available")
@@ -432,10 +456,8 @@ import ThermalSDK
         FlirLogger.log(.discovery, "Stopping discovery...")
         
 #if FLIR_ENABLED
-        discovery?.stop()
-        isScanning = false
-        FlirLogger.log(.discovery, "Discovery stopped")
-#endif
+        discoveryTimeoutWorkItem?.cancel()
+        discoveryTimeoutWorkItem = nil
     }
     
     // MARK: - Connection
@@ -486,19 +508,29 @@ import ThermalSDK
             return
         }
         
-        // Handle authentication for generic cameras (network cameras)
+        // Fail-fast authentication for generic/network cameras (prevent indefinite blocking)
         if identity.cameraType() == .generic {
             FlirLogger.log(.connection, "Generic/network camera - starting authentication...")
             let certName = getCertificateName()
-            var status = FLIRAuthenticationStatus.pending
-            while status == .pending {
-                status = cam.authenticate(identity, trustedConnectionName: certName)
-                if status == .pending {
-                    FlirLogger.log(.connection, "Waiting for camera authentication approval...")
+            var authStatus = FLIRAuthenticationStatus.pending
+            var attempts = 0
+            let maxAttempts = 10
+            while authStatus == .pending && attempts < maxAttempts {
+                authStatus = cam.authenticate(identity, trustedConnectionName: certName)
+                if authStatus == .pending {
+                    FlirLogger.log(.connection, "Authentication pending... attempt \(attempts + 1)")
                     Thread.sleep(forTimeInterval: 1.0)
+                    attempts += 1
+                }
+            }
+            FlirLogger.log(.connection, "Authentication status: \(authStatus.rawValue)")
+            if authStatus == .pending {
+                FlirLogger.logError(.connection, "Authentication timed out for device: \(identity.deviceId())")
+                DispatchQueue.main.async { [weak self] in
+                    self?.delegate?.onError("Authentication timed out")
                 }
+                return
             }
-            FlirLogger.log(.connection, "Authentication status: \(status.rawValue)")
         }
         
         do {
@@ -512,6 +544,7 @@ import ThermalSDK
             FlirLogger.log(.connection, "Step 2: Connecting to device...")
             try cam.connect()
             FlirLogger.log(.connection, "✅ Connected successfully to: \(identity.deviceId())")
+
             
             // Update state
             connectedIdentity = identity
@@ -609,10 +642,9 @@ import ThermalSDK
         FlirLogger.log(.streaming, "Stopping stream...")
         
 #if FLIR_ENABLED
-        stream?.stop()
-        stream = nil
-        streamer = nil
-        _isStreaming = false
+        // Cancel any pending watchdog to avoid false positives after an explicit stop
+        streamWatchdogWorkItem?.cancel()
+        streamWatchdogWorkItem = nil
         emitStateChange("connected")
         FlirLogger.log(.streaming, "Stream stopped")
 #endif
@@ -637,6 +669,28 @@ import ThermalSDK
             _isStreaming = true
             emitStateChange("streaming")
             FlirLogger.log(.streaming, "✅ Stream started successfully (thermal=\(newStream.isThermal))")
+
+            // Schedule a short watchdog to detect silent no-frame scenarios.
+            streamWatchdogWorkItem?.cancel()
+            let watch = DispatchWorkItem { [weak self] in
+                guard let self = self else { return }
+                if self._latestImage == nil {
+                    FlirLogger.logError(.streaming, "No frames received within watchdog period after stream start")
+                    // Attempt a soft restart
+                    do {
+                        self.stream?.stop()
+                        try self.stream?.start()
+                        FlirLogger.log(.streaming, "Attempted stream restart")
+                    } catch {
+                        FlirLogger.logError(.streaming, "Stream restart failed", error: error)
+                        DispatchQueue.main.async {
+                            self.delegate?.onError("No frames received after starting stream")
+                        }
+                    }
+                }
+            }
+            streamWatchdogWorkItem = watch
+            DispatchQueue.main.asyncAfter(deadline: .now() + 3.0, execute: watch)
         } catch {
             FlirLogger.logError(.streaming, "Stream start failed", error: error)
             stream = nil
@@ -916,7 +970,11 @@ extension FlirManager: FLIRDiscoveryEventDelegate {
     public func discoveryError(_ error: String, netServiceError nsnetserviceserror: Int32, on iface: FLIRCommunicationInterface) {
         FlirLogger.logError(.discovery, "Discovery error: \(error) (code=\(nsnetserviceserror)) on interface: \(iface)")
         
+        // Stop scanning and emit current device list so UI can recover
+        discovery?.stop()
+        isScanning = false
         DispatchQueue.main.async { [weak self] in
+            self?.delegate?.onDevicesFound(self?.discoveredDevices ?? [])
             self?.delegate?.onError("Discovery error: \(error)")
         }
     }
@@ -924,6 +982,18 @@ extension FlirManager: FLIRDiscoveryEventDelegate {
     public func discoveryFinished(_ iface: FLIRCommunicationInterface) {
         FlirLogger.log(.discovery, "Discovery finished on interface: \(iface)")
         isScanning = false
+        // Emit final list so consumers can update even if discovery ended quietly
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.delegate?.onDevicesFound(self.discoveredDevices)
+            // If no devices were found, emit an explicit no_device_found state
+            if self.discoveredDevices.isEmpty {
+                self.emitStateChange("no_device_found")
+            }
+        }
+        // Cancel the timeout if discovery finished normally
+        discoveryTimeoutWorkItem?.cancel()
+        discoveryTimeoutWorkItem = nil
     }
 }
 

package/ios/Flir/src/FlirModule.m

@@ -155,9 +155,14 @@ RCT_EXPORT_METHOD(addListener : (NSString *)eventName) {
       if (manager) {
         NSArray *devices = ((NSArray * (*)(id, SEL))
                            objc_msgSend)(manager, sel_registerName("getDiscoveredDevices"));
-        if (devices && devices.count > 0) {
-          NSLog(@"[FlirModule] addListener - re-emitting %lu discovered devices", (unsigned long)devices.count);
+        // Re-emit even if the device list is empty so JS listeners can
+        // observe a 'no devices found' state and avoid hanging while waiting.
+        if (devices) {
+          NSLog(@"[FlirModule] addListener - re-emitting discovered devices (count=%lu)", (unsigned long)devices.count);
           [self onDevicesFound:devices];
+        } else {
+          NSLog(@"[FlirModule] addListener - no discovered devices available to re-emit");
+          [self onDevicesFound:@[]];
         }
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilabs-flir",
-  "version": "2.2.2",
+  "version": "2.2.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",