ilabs-flir 2.3.10 → 2.3.12

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

@@ -23,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;
@@ -51,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);
@@ -152,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() {
@@ -199,62 +197,86 @@ 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.getCameraDetails() != null) {
+                        String ssid = dc.getCameraDetails().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.getCameraDetails(), 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;
+                        }
+                    } 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 = 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);
@@ -264,7 +286,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());
             }
@@ -295,6 +317,10 @@ public class FlirSdkManager {
         return camera != null;
     }
 
+    private DiscoveredCamera getDiscoveredCamera(String deviceId) {
+        return discoveredCameras.get(deviceId);
+    }
+
     // ==================== STREAMING ====================
 
     public void startStream() {
@@ -317,18 +343,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) {
@@ -531,6 +589,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) {
@@ -553,6 +613,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 }
             

package/package.json

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