ilabs-flir 2.2.1 → 2.2.3

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

@@ -174,25 +174,35 @@ import ThermalSDK
     }
 
     @objc public func getBatteryLevel() -> Int {
-#if FLIR_ENABLED
-        if let cam = camera {
-            if let val = cam.value(forKey: "batteryLevel") as? Int { return val }
-            if let batt = cam.value(forKey: "battery") as? NSObject,
-               let lv = batt.value(forKey: "level") as? Int { return lv }
+        // Emulators don't have battery - return -1 immediately
+        if isEmulator {
+            return -1
         }
-#endif
+        
+#if FLIR_ENABLED
+        // Only try battery access on real hardware (not emulators)
+        // Note: KVC can throw NSException which Swift can't catch
+        // So we avoid using KVC entirely for battery
+        return -1  // TODO: Find safe API to access battery without KVC
+#else
         return -1
+#endif
     }
 
     @objc public func isBatteryCharging() -> Bool {
-#if FLIR_ENABLED
-        if let cam = camera {
-            if let ch = cam.value(forKey: "isCharging") as? Bool { return ch }
-            if let batt = cam.value(forKey: "battery") as? NSObject,
-               let ch = batt.value(forKey: "charging") as? Bool { return ch }
+        // Emulators don't have battery - return false immediately
+        if isEmulator {
+            return false
         }
-#endif
+        
+#if FLIR_ENABLED
+        // Only try battery access on real hardware (not emulators)
+        // Note: KVC can throw NSException which Swift can't catch
+        // So we avoid using KVC entirely for battery
+        return false  // TODO: Find safe API to access battery without KVC
+#else
         return false
+#endif
     }
 
     @objc public func latestFrameImage() -> UIImage? {
@@ -701,7 +711,10 @@ import ThermalSDK
     // MARK: - Battery Polling (like Android)
     
     private func startBatteryPolling() {
-        FlirLogger.log(.battery, "Starting battery polling timer (5s interval)")
+        // Don't poll battery on emulators - they don't have batteries
+        if isEmulator {
+            return
+        }
         
         // Cancel any existing timer
         stopBatteryPolling()
@@ -717,9 +730,6 @@ import ThermalSDK
     }
     
     private func stopBatteryPolling() {
-        if batteryPollingTimer != nil {
-            FlirLogger.log(.battery, "Stopping battery polling timer")
-        }
         batteryPollingTimer?.invalidate()
         batteryPollingTimer = nil
     }
@@ -728,13 +738,11 @@ import ThermalSDK
         let level = getBatteryLevel()
         let charging = isBatteryCharging()
         
-        // Only log and emit if values changed
+        // Only emit if values changed
         if level != lastPolledBatteryLevel || charging != lastPolledCharging {
             lastPolledBatteryLevel = level
             lastPolledCharging = charging
             
-            FlirLogger.logBattery(level: level, isCharging: charging)
-            
             // Emit to delegate/RN via notification
             NotificationCenter.default.post(
                 name: Notification.Name("FlirBatteryUpdated"),

package/ios/Flir/src/FlirModule.m

@@ -129,10 +129,24 @@ RCT_EXPORT_MODULE(FlirModule);
   ];
 }
 
+- (void)startObserving {
+  // Called automatically by RCTEventEmitter when first listener is added
+  // This ensures the parent class knows we have listeners
+}
+
+- (void)stopObserving {
+  // Called automatically by RCTEventEmitter when last listener is removed
+}
+
 RCT_EXPORT_METHOD(addListener : (NSString *)eventName) {
   _listenerCount++;
   NSLog(@"[FlirModule] addListener: %@ (count: %ld)", eventName, (long)_listenerCount);
   
+  // CRITICAL: Call parent to register with RCTEventEmitter's internal tracking
+  // Without this, sendEventWithName will show "no listeners registered" warning
+  // and may not deliver events properly
+  [super addListener:eventName];
+  
   // When FlirDevicesFound listener is added, immediately emit current device list
   // This handles the case where discovery happened before React Native mounted
   if ([eventName isEqualToString:@"FlirDevicesFound"]) {
@@ -154,6 +168,9 @@ RCT_EXPORT_METHOD(removeListeners : (NSInteger)count) {
   _listenerCount -= count;
   if (_listenerCount < 0) _listenerCount = 0;
   NSLog(@"[FlirModule] removeListeners: %ld (remaining: %ld)", (long)count, (long)_listenerCount);
+  
+  // CRITICAL: Call parent to unregister with RCTEventEmitter's internal tracking
+  [super removeListeners:count];
 }
 
 + (void)emitBatteryUpdateWithLevel:(NSInteger)level charging:(BOOL)charging {
@@ -234,18 +251,26 @@ RCT_EXPORT_METHOD(getDiscoveredDevices : (RCTPromiseResolveBlock)
 RCT_EXPORT_METHOD(connectToDevice : (NSString *)deviceId resolver : (
     RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
   dispatch_async(dispatch_get_main_queue(), ^{
-    self.connectResolve = resolve;
-    self.connectReject = reject;
+    NSLog(@"[FlirModule] connectToDevice called for: %@", deviceId);
 
     id manager = flir_manager_shared();
     if (manager &&
         [manager respondsToSelector:sel_registerName("connectToDevice:")]) {
+      NSLog(@"[FlirModule] Calling FlirManager.connectToDevice");
+      
+      // Store callbacks for event-driven updates (but don't block on them)
+      self.connectResolve = nil;  // Don't use promise for blocking
+      self.connectReject = nil;
+      
+      // Initiate connection asynchronously
       ((void (*)(id, SEL, id))objc_msgSend)(
           manager, sel_registerName("connectToDevice:"), deviceId);
+      
+      // Resolve immediately - connection status will come via events
+      resolve(@(YES));
     } else {
+      NSLog(@"[FlirModule] FlirManager not found");
       reject(@"ERR_NO_MANAGER", @"FlirManager not found", nil);
-      self.connectResolve = nil;
-      self.connectReject = nil;
     }
   });
 }
@@ -277,16 +302,21 @@ RCT_EXPORT_METHOD(stopFlir : (RCTPromiseResolveBlock)
 RCT_EXPORT_METHOD(startEmulator : (NSString *)emulatorType resolver : (
     RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
   dispatch_async(dispatch_get_main_queue(), ^{
-    self.connectResolve = resolve;
-    self.connectReject = reject;
+    NSLog(@"[FlirModule] startEmulator called for type: %@", emulatorType);
+    
     id manager = flir_manager_shared();
     if (manager && [manager respondsToSelector:sel_registerName(
                                                    "startEmulatorWithType:")]) {
-      // Swift: startEmulator(type: String) -> exposed as startEmulatorWithType:
-      // ? Or startEmulatorWith? Swift default naming: startEmulator(type:) ->
-      // startEmulatorWithType:
+      // Store callbacks for event-driven updates (but don't block on them)
+      self.connectResolve = nil;
+      self.connectReject = nil;
+      
+      // Initiate emulator start asynchronously
       ((void (*)(id, SEL, id))objc_msgSend)(
           manager, sel_registerName("startEmulatorWithType:"), emulatorType);
+      
+      // Resolve immediately - connection status will come via events
+      resolve(@(YES));
     } else {
       // Fallback if selector assumption wrong/mismatch
       reject(@"ERR_NOT_IMPL",
@@ -444,12 +474,6 @@ RCT_EXPORT_METHOD(isPreferSdkRotation : (RCTPromiseResolveBlock)
 }
 
 - (void)onDeviceConnected:(id)device {
-  if (self.connectResolve) {
-    self.connectResolve(@(YES));
-    self.connectResolve = nil;
-    self.connectReject = nil;
-  }
-
   // device is FlirDeviceInfo
   NSMutableDictionary *body = [NSMutableDictionary new];
   if ([device respondsToSelector:sel_registerName("toDictionary")]) {
@@ -497,11 +521,6 @@ RCT_EXPORT_METHOD(isPreferSdkRotation : (RCTPromiseResolveBlock)
 }
 
 - (void)onError:(NSString *)message {
-  if (self.connectReject) {
-    self.connectReject(@"ERR_FLIR", message, nil);
-    self.connectResolve = nil;
-    self.connectReject = nil;
-  }
   NSLog(@"[FlirModule] onError - emitting FlirError: %@", message);
   [self sendEventWithName:@"FlirError"
                      body:@{@"error" : message ?: @"Unknown error"}];

package/package.json

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