ilabs-flir 1.0.5 → 1.0.6

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

@@ -1,19 +1,15 @@
 package flir.android;
 
+import android.content.Context;
 import android.graphics.Bitmap;
-import android.os.Handler;
-import android.os.Looper;
 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.JavaImageBuffer;
 import com.flir.thermalsdk.image.Palette;
 import com.flir.thermalsdk.image.PaletteManager;
 import com.flir.thermalsdk.image.Point;
-import com.flir.thermalsdk.image.ThermalImage;
 import com.flir.thermalsdk.image.ThermalValue;
 import com.flir.thermalsdk.live.Camera;
 import com.flir.thermalsdk.live.CommunicationInterface;
@@ -24,737 +20,562 @@ 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.live.remote.OnReceived;
-import com.flir.thermalsdk.live.remote.OnRemoteError;
 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.List;
-import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
- * FLIR SDK Manager - Handles device discovery, connection, and streaming.
- * Uses the official FLIR ThermalSDK directly (bundled in AAR).
- * 
- * Supports USB, NETWORK (FLIR ONE Edge), and EMULATOR interfaces.
+ * Simplified FLIR SDK Manager - handles discovery, connection, and streaming
+ * No filtering - returns all discovered devices (USB, Network, Emulator)
  */
 public class FlirSdkManager {
     private static final String TAG = "FlirSdkManager";
-    private static final String FLOW_TAG = "FLIR_FLOW";
     
-    // Discovery timeout in milliseconds
-    private static final long DISCOVERY_TIMEOUT_DEVICE_MS = 5000;
-    private static final long DISCOVERY_TIMEOUT_EMULATOR_MS = 0;
+    // Singleton instance
+    private static FlirSdkManager instance;
+    
+    // Core components
+    private final Context context;
+    // Use bounded thread pool to prevent thread explosion during rapid frame processing
+    private final Executor executor = Executors.newFixedThreadPool(2);
+    // Single-threaded executor for frame processing to ensure ordered processing
+    private final Executor frameExecutor = Executors.newSingleThreadExecutor();
+    // Frame processing guard - skip frames if still processing previous one
+    private volatile boolean isProcessingFrame = false;
+    private long lastFrameProcessedMs = 0;
+    private static final long MIN_FRAME_INTERVAL_MS = 50; // Max ~20 FPS frame processing
+    
+    // State
+    private boolean isInitialized = false;
+    private boolean isScanning = false;
+    private Camera camera;
+    private ThermalStreamer streamer;
+    private Stream activeStream;
+    private final List<Identity> discoveredDevices = Collections.synchronizedList(new ArrayList<>());
+    
+    // Listener
+    private Listener listener;
     
-    // Emulator types
-    public enum EmulatorType {
-        FLIR_ONE_EDGE,  // WiFi emulator
-        FLIR_ONE        // USB emulator
-    }
-    
-    // Communication interfaces
-    public enum CommInterface {
-        USB,
-        NETWORK,
-        EMULATOR
-    }
-
-    // Listener interface for callbacks
+    /**
+     * Listener interface for SDK events
+     */
     public interface Listener {
+        void onDeviceFound(Identity identity);
+        void onDeviceListUpdated(List<Identity> devices);
+        void onConnected(Identity identity);
+        void onDisconnected();
         void onFrame(Bitmap bitmap);
-        void onTemperature(double temp, int x, int y);
-        void onDeviceFound(String deviceId, String deviceName, boolean isEmulator);
-        void onDeviceListUpdated(List<DeviceInfo> devices);
-        void onDeviceConnected(String deviceId, String deviceName, boolean isEmulator);
-        void onDeviceDisconnected();
-        void onDiscoveryStarted();
-        void onDiscoveryTimeout();
-        void onStreamStarted(String streamType);
-        void onError(String error);
+        void onError(String message);
     }
     
-    // Device info class
-    public static class DeviceInfo {
-        public final String deviceId;
-        public final String deviceName;
-        public final boolean isEmulator;
-        public final CommInterface commInterface;
-        public final Identity identity;
-        
-        DeviceInfo(String id, String name, boolean emu, CommInterface iface, Identity identity) {
-            this.deviceId = id;
-            this.deviceName = name;
-            this.isEmulator = emu;
-            this.commInterface = iface;
-            this.identity = identity;
-        }
+    // Private constructor for singleton
+    private FlirSdkManager(Context context) {
+        this.context = context.getApplicationContext();
     }
-
-    private final Listener listener;
-    private final android.content.Context appContext;
-    private final Handler mainHandler = new Handler(Looper.getMainLooper());
-    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
-    
-    // SDK objects
-    private Camera camera = null;
-    private Stream currentStream = null;
-    private ThermalStreamer thermalStreamer = null;
-    private Palette currentPalette = null;
     
-    // State tracking
-    private final AtomicBoolean isDiscovering = new AtomicBoolean(false);
-    private final AtomicBoolean isConnected = new AtomicBoolean(false);
-    private final AtomicBoolean isStreaming = new AtomicBoolean(false);
-    private final AtomicBoolean isEmulatorMode = new AtomicBoolean(false);
-    private final CopyOnWriteArrayList<DeviceInfo> discoveredDevices = new CopyOnWriteArrayList<>();
-    private ScheduledFuture<?> discoveryTimeoutFuture = null;
-    private DeviceInfo connectedDevice = null;
-    private EmulatorType emulatorType = EmulatorType.FLIR_ONE_EDGE;
-    
-    // Frame state
-    private volatile Bitmap latestFrame = null;
-    private volatile ThermalImage currentThermalImage = null;
-    private String currentStreamKind = null;
-    
-    // Step tracking for debugging
-    private int stepCounter = 0;
-    private long flowStartTime = 0;
-    
-    // SDK initialization state
-    private static boolean sdkInitialized = false;
-
-    FlirSdkManager(Listener listener, android.content.Context context) {
-        this.listener = listener;
-        this.appContext = context != null ? context.getApplicationContext() : null;
-    }
-    
-    private void logStep(String step, String details) {
-        stepCounter++;
-        long elapsed = flowStartTime > 0 ? System.currentTimeMillis() - flowStartTime : 0;
-        Log.i(FLOW_TAG, String.format("[Step %d] [+%dms] %s: %s", stepCounter, elapsed, step, details));
+    /**
+     * Get singleton instance
+     */
+    public static synchronized FlirSdkManager getInstance(Context context) {
+        if (instance == null) {
+            instance = new FlirSdkManager(context);
+        }
+        return instance;
     }
     
-    private void resetFlowTracking() {
-        stepCounter = 0;
-        flowStartTime = System.currentTimeMillis();
-        Log.i(FLOW_TAG, "========== FLIR FLOW STARTED ==========");
+    /**
+     * Set listener for SDK events
+     */
+    public void setListener(Listener listener) {
+        this.listener = listener;
     }
     
-    // ==================== SDK INITIALIZATION ====================
-    
-    private boolean initializeSdk() {
-        if (sdkInitialized) {
-            Log.d(TAG, "[FLIR SDK] Already initialized");
-            return true;
-        }
-        
-        if (appContext == null) {
-            Log.e(TAG, "[FLIR SDK] No context available");
-            return false;
+    /**
+     * Initialize the FLIR Thermal SDK
+     */
+    public void initialize() {
+        if (isInitialized) {
+            Log.d(TAG, "Already initialized");
+            return;
         }
         
         try {
-            Log.i(TAG, "[FLIR SDK] Initializing ThermalSdkAndroid...");
-            ThermalSdkAndroid.init(appContext);
-            sdkInitialized = true;
-            Log.i(TAG, "[FLIR SDK] SDK Version: " + ThermalSdkAndroid.getVersion());
-            return true;
-        } catch (Throwable t) {
-            Log.e(TAG, "[FLIR SDK] Initialization failed: " + t.getMessage(), t);
-            notifyError("SDK initialization failed: " + t.getMessage());
-            return false;
+            ThermalSdkAndroid.init(context);
+            isInitialized = true;
+            Log.d(TAG, "SDK initialized successfully");
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to initialize SDK", e);
+            notifyError("SDK initialization failed: " + e.getMessage());
         }
     }
     
-    // ==================== PUBLIC API ====================
-    
-    public void setEmulatorType(EmulatorType type) {
-        this.emulatorType = type;
-        Log.i(TAG, "[FLIR] Emulator type set to: " + type);
-        logStep("SET_EMULATOR_TYPE", "type=" + type);
+    /**
+     * Check if SDK is initialized
+     */
+    public boolean isInitialized() {
+        return isInitialized;
     }
     
-    public void startDiscovery(boolean forceEmulator) {
-        resetFlowTracking();
-        logStep("START_DISCOVERY", "forceEmulator=" + forceEmulator + ", emulatorType=" + emulatorType);
-        Log.i(TAG, "[FLIR] startDiscovery(forceEmulator=" + forceEmulator + ")");
+    /**
+     * Start scanning for all device types (USB, Network, Emulator)
+     * Returns ALL devices - no filtering
+     */
+    public void scan() {
+        if (!isInitialized) {
+            Log.e(TAG, "SDK not initialized");
+            notifyError("SDK not initialized");
+            return;
+        }
         
-        // Disconnect current device first
-        if (isConnected.get()) {
-            logStep("DISCONNECT_PREVIOUS", "Disconnecting current device");
-            disconnect();
+        if (isScanning) {
+            Log.d(TAG, "Already scanning");
+            return;
         }
         
+        isScanning = true;
         discoveredDevices.clear();
-        logStep("CLEAR_DEVICES", "Cleared discovered devices list");
         
-        if (forceEmulator) {
-            logStep("MODE_EMULATOR", "Forcing emulator mode");
-            isEmulatorMode.set(true);
-            startEmulatorDiscovery();
-        } else {
-            logStep("MODE_FULL_DISCOVERY", "Starting full discovery, timeout=" + DISCOVERY_TIMEOUT_DEVICE_MS + "ms");
-            isEmulatorMode.set(false);
-            startFullDiscovery();
-        }
-    }
-    
-    public void stopDiscovery() {
-        Log.i(TAG, "[FLIR] stopDiscovery()");
-        cancelDiscoveryTimeout();
-        isDiscovering.set(false);
+        Log.d(TAG, "Starting discovery for EMULATOR, NETWORK, USB...");
         
         try {
-            DiscoveryFactory.getInstance().stop();
-        } catch (Throwable t) {
-            Log.w(TAG, "[FLIR] stopDiscovery failed: " + t.getMessage());
+            DiscoveryFactory.getInstance().scan(
+                discoveryListener,
+                CommunicationInterface.EMULATOR,
+                CommunicationInterface.NETWORK,
+                CommunicationInterface.USB
+            );
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to start scan", e);
+            isScanning = false;
+            notifyError("Scan failed: " + e.getMessage());
         }
     }
     
-    public void connectToDevice(String deviceId) {
-        Log.i(TAG, "[FLIR] connectToDevice: " + deviceId);
+    /**
+     * Stop scanning for devices
+     */
+    public void stop() {
+        if (!isScanning) {
+            return;
+        }
         
-        DeviceInfo target = null;
-        for (DeviceInfo d : discoveredDevices) {
-            if (d.deviceId.equals(deviceId)) {
-                target = d;
-                break;
-            }
+        try {
+            DiscoveryFactory.getInstance().stop(
+                CommunicationInterface.EMULATOR,
+                CommunicationInterface.NETWORK,
+                CommunicationInterface.USB
+            );
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to stop scan", e);
         }
         
-        if (target == null) {
-            notifyError("Device not found: " + deviceId);
+        isScanning = false;
+        Log.d(TAG, "Discovery stopped");
+    }
+    
+    /**
+     * Get list of discovered devices
+     */
+    public List<Identity> getDiscoveredDevices() {
+        return new ArrayList<>(discoveredDevices);
+    }
+    
+    /**
+     * Connect to a device
+     */
+    public void connect(Identity identity) {
+        if (identity == null) {
+            notifyError("Invalid identity");
             return;
         }
         
-        if (isConnected.get()) {
+        // Disconnect if already connected
+        if (camera != null) {
             disconnect();
         }
         
-        connectToIdentity(target);
+        Log.d(TAG, "Connecting to: " + identity.deviceId);
+        
+        // Run connection on background thread since it's blocking
+        executor.execute(() -> {
+            try {
+                camera = new Camera();
+                camera.connect(identity, connectionStatusListener, new ConnectParameters());
+                
+                Log.d(TAG, "Connected to camera");
+                
+                if (listener != null) {
+                    listener.onConnected(identity);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Connection failed", e);
+                camera = null;
+                notifyError("Connection failed: " + e.getMessage());
+            }
+        });
     }
     
+    /**
+     * Disconnect from current device
+     */
     public void disconnect() {
-        Log.i(TAG, "[FLIR] disconnect()");
-        
-        stopStreaming();
+        stopStream();
         
         if (camera != null) {
             try {
                 camera.disconnect();
-            } catch (Throwable t) {
-                Log.w(TAG, "[FLIR] Camera disconnect failed: " + t.getMessage());
+            } catch (Exception e) {
+                Log.e(TAG, "Error disconnecting", e);
             }
             camera = null;
         }
         
-        isConnected.set(false);
-        connectedDevice = null;
+        if (listener != null) {
+            listener.onDisconnected();
+        }
         
-        mainHandler.post(() -> {
-            if (listener != null) {
-                listener.onDeviceDisconnected();
-            }
-        });
+        Log.d(TAG, "Disconnected");
     }
     
-    public void setStreamType(String streamType) {
-        Log.i(TAG, "[FLIR] setStreamType: " + streamType);
-        currentStreamKind = streamType;
-        
-        if (isConnected.get() && camera != null) {
-            stopStreaming();
-            startStreaming();
-        }
+    /**
+     * Check if connected
+     */
+    public boolean isConnected() {
+        return camera != null;
     }
     
-    public void setPalette(String paletteName) {
-        Log.i(TAG, "[FLIR] setPalette: " + paletteName);
+    /**
+     * Start streaming from connected device
+     */
+    public void startStream() {
+        if (camera == null) {
+            notifyError("Not connected");
+            return;
+        }
         
-        try {
-            List<Palette> palettes = PaletteManager.getDefaultPalettes();
-            for (Palette p : palettes) {
-                if (p.name.equalsIgnoreCase(paletteName)) {
-                    currentPalette = p;
-                    Log.i(TAG, "[FLIR] Palette set to: " + p.name);
+        executor.execute(() -> {
+            try {
+                // Get available streams
+                List<Stream> streams = camera.getStreams();
+                if (streams == null || streams.isEmpty()) {
+                    notifyError("No streams available");
                     return;
                 }
+                
+                // Find thermal stream
+                Stream thermalStream = null;
+                for (Stream stream : streams) {
+                    if (stream.isThermal()) {
+                        thermalStream = stream;
+                        break;
+                    }
+                }
+                
+                if (thermalStream == null) {
+                    thermalStream = streams.get(0);
+                }
+                
+                activeStream = thermalStream;
+                streamer = new ThermalStreamer(thermalStream);
+                
+                // Start receiving frames using OnReceived and OnRemoteError
+                thermalStream.start(
+                    (OnReceived<Void>) v -> {
+                        // FRAME DROP GUARD: Skip frame if still processing previous one
+                        // This prevents thread buildup and ensures smooth frame flow
+                        long now = System.currentTimeMillis();
+                        if (isProcessingFrame || (now - lastFrameProcessedMs < MIN_FRAME_INTERVAL_MS)) {
+                            // Drop frame - processing is behind or too soon since last frame
+                            return;
+                        }
+                        
+                        // Mark processing start before queuing task
+                        isProcessingFrame = true;
+                        
+                        // Use single-threaded frameExecutor to ensure ordered frame processing
+                        frameExecutor.execute(() -> {
+                            try {
+                                if (streamer != null) {
+                                    streamer.update();
+                                    
+                                    // Get ImageBuffer and convert to Bitmap
+                                    ImageBuffer imageBuffer = streamer.getImage();
+                                    if (imageBuffer != null && listener != null) {
+                                        BitmapAndroid bitmapAndroid = BitmapAndroid.createBitmap(imageBuffer);
+                                        Bitmap bitmap = bitmapAndroid.getBitMap();
+                                        if (bitmap != null) {
+                                            listener.onFrame(bitmap);
+                                        }
+                                    }
+                                }
+                            } catch (Exception e) {
+                                Log.e(TAG, "Error processing frame", e);
+                            } finally {
+                                // Reset frame processing guard to allow next frame
+                                lastFrameProcessedMs = System.currentTimeMillis();
+                                isProcessingFrame = false;
+                            }
+                        });
+                    },
+                    error -> {
+                        Log.e(TAG, "Stream error: " + error);
+                        notifyError("Stream error: " + error);
+                    }
+                );
+                
+                Log.d(TAG, "Streaming started");
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Failed to start stream", e);
+                notifyError("Stream failed: " + e.getMessage());
             }
-            Log.w(TAG, "[FLIR] Palette not found: " + paletteName);
-        } catch (Throwable t) {
-            Log.w(TAG, "[FLIR] setPalette failed: " + t.getMessage());
-        }
+        });
     }
     
-    public void getTemperatureAt(int x, int y, Bitmap source) {
-        Log.d(TAG, "[FLIR] getTemperatureAt(" + x + ", " + y + ")");
-        double temp = getTemperatureAtPoint(x, y);
-        if (!Double.isNaN(temp) && listener != null) {
-            mainHandler.post(() -> listener.onTemperature(temp, x, y));
+    /**
+     * Stop streaming
+     */
+    public void stopStream() {
+        if (activeStream != null) {
+            try {
+                activeStream.stop();
+            } catch (Exception e) {
+                Log.e(TAG, "Error stopping stream", e);
+            }
+            activeStream = null;
         }
+        
+        streamer = null;
+        
+        // Reset frame processing state
+        isProcessingFrame = false;
+        lastFrameProcessedMs = 0;
+        
+        Log.d(TAG, "Streaming stopped");
     }
     
     /**
-     * Get temperature at a specific point from the current thermal image
+     * Get temperature at a specific point in the image
+     * Queries the SDK directly - simple and no locks needed
+     * @param x X coordinate (0 to image width-1)
+     * @param y Y coordinate (0 to image height-1)
+     * @return Temperature in Celsius, or Double.NaN if not available
      */
-    public double getTemperatureAtPoint(int x, int y) {
-        if (currentThermalImage == null) {
+    public double getTemperatureAt(int x, int y) {
+        if (streamer == null) {
             return Double.NaN;
         }
         
+        final double[] result = {Double.NaN};
         try {
-            // Clamp coordinates to image bounds
-            int imgWidth = currentThermalImage.getWidth();
-            int imgHeight = currentThermalImage.getHeight();
-            int clampedX = Math.max(0, Math.min(x, imgWidth - 1));
-            int clampedY = Math.max(0, Math.min(y, imgHeight - 1));
-            
-            ThermalValue value = currentThermalImage.getValueAt(new Point(clampedX, clampedY));
-            if (value != null) {
-                return value.asCelsius().value;
-            }
-        } catch (Throwable t) {
-            Log.w(TAG, "[FLIR] getTemperatureAtPoint failed: " + t.getMessage());
+            streamer.withThermalImage(thermalImage -> {
+                try {
+                    int imgWidth = thermalImage.getWidth();
+                    int imgHeight = thermalImage.getHeight();
+                    
+                    int clampedX = Math.max(0, Math.min(imgWidth - 1, x));
+                    int clampedY = Math.max(0, Math.min(imgHeight - 1, y));
+                    
+                    ThermalValue value = thermalImage.getValueAt(new Point(clampedX, clampedY));
+                    if (value != null) {
+                        result[0] = value.asCelsius().value;
+                    }
+                } catch (Exception e) {
+                    Log.w(TAG, "Error querying temperature", e);
+                }
+            });
+        } catch (Exception e) {
+            Log.w(TAG, "Temperature query failed", e);
         }
-        return Double.NaN;
-    }
-    
-    public Bitmap getLatestFrame() {
-        return latestFrame;
-    }
-    
-    public List<DeviceInfo> getDiscoveredDevices() {
-        return new ArrayList<>(discoveredDevices);
-    }
-    
-    public boolean isConnected() {
-        return isConnected.get();
-    }
-    
-    public boolean isStreaming() {
-        return isStreaming.get();
-    }
-    
-    public void destroy() {
-        Log.i(TAG, "[FLIR] destroy()");
-        stopDiscovery();
-        disconnect();
-        scheduler.shutdown();
+        
+        return result[0];
     }
     
-    // ==================== DISCOVERY ====================
-    
-    private void startFullDiscovery() {
-        Log.i(TAG, "[FLIR] Starting full discovery (USB, NETWORK, EMULATOR)");
-        
-        if (!initializeSdk()) {
-            Log.w(TAG, "[FLIR] SDK not available, falling back to emulator");
-            startEmulatorDiscovery();
-            return;
+    /**
+     * Get temperature at normalized coordinates (0.0 to 1.0)
+     * @param normalizedX X coordinate (0.0 to 1.0)
+     * @param normalizedY Y coordinate (0.0 to 1.0)
+     * @return Temperature in Celsius, or Double.NaN if not available
+     */
+    public double getTemperatureAtNormalized(double normalizedX, double normalizedY) {
+        if (streamer == null) {
+            return Double.NaN;
         }
         
-        isDiscovering.set(true);
-        mainHandler.post(() -> {
-            if (listener != null) {
-                listener.onDiscoveryStarted();
-            }
-        });
-        
+        final double[] result = {Double.NaN};
         try {
-            CommunicationInterface[] interfaces = {
-                CommunicationInterface.USB,
-                CommunicationInterface.NETWORK,
-                CommunicationInterface.EMULATOR
-            };
-            
-            DiscoveryFactory.getInstance().scan(new DiscoveryEventListener() {
-                @Override
-                public void onCameraFound(DiscoveredCamera discoveredCamera) {
-                    handleCameraFound(discoveredCamera);
-                }
-                
-                @Override
-                public void onDiscoveryError(CommunicationInterface iface, ErrorCode errorCode) {
-                    Log.w(TAG, "[FLIR] Discovery error on " + iface + ": " + errorCode);
+            streamer.withThermalImage(thermalImage -> {
+                try {
+                    int width = thermalImage.getWidth();
+                    int height = thermalImage.getHeight();
+                    
+                    int x = (int) (normalizedX * (width - 1));
+                    int y = (int) (normalizedY * (height - 1));
+                    
+                    x = Math.max(0, Math.min(width - 1, x));
+                    y = Math.max(0, Math.min(height - 1, y));
+                    
+                    ThermalValue value = thermalImage.getValueAt(new Point(x, y));
+                    if (value != null) {
+                        result[0] = value.asCelsius().value;
+                    }
+                } catch (Exception e) {
+                    Log.w(TAG, "Error querying temperature (normalized)", e);
                 }
-            }, interfaces);
-            
-            // Set timeout for device discovery
-            scheduleDiscoveryTimeout(DISCOVERY_TIMEOUT_DEVICE_MS);
-            
-        } catch (Throwable t) {
-            Log.e(TAG, "[FLIR] startFullDiscovery failed: " + t.getMessage(), t);
-            notifyError("Discovery failed: " + t.getMessage());
-            startEmulatorDiscovery();
+            });
+        } catch (Exception e) {
+            Log.w(TAG, "Temperature query failed", e);
         }
+        
+        return result[0];
     }
     
-    private void startEmulatorDiscovery() {
-        logStep("EMULATOR_DISCOVERY_START", "type=" + emulatorType);
-        Log.i(TAG, "[FLIR] Starting emulator discovery (type=" + emulatorType + ")");
-        
-        if (!initializeSdk()) {
-            notifyError("SDK initialization failed");
+    /**
+     * Set palette for thermal image rendering
+     */
+    public void setPalette(String paletteName) {
+        if (streamer == null) {
+            Log.w(TAG, "No active streamer");
             return;
         }
         
-        isDiscovering.set(true);
-        isEmulatorMode.set(true);
-        
-        mainHandler.post(() -> {
-            if (listener != null) {
-                listener.onDiscoveryStarted();
+        executor.execute(() -> {
+            try {
+                Palette palette = findPalette(paletteName);
+                if (palette != null) {
+                    streamer.withThermalImage(thermalImage -> {
+                        thermalImage.setPalette(palette);
+                    });
+                    Log.d(TAG, "Palette set to: " + paletteName);
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error setting palette", e);
             }
         });
-        
-        try {
-            DiscoveryFactory.getInstance().scan(new DiscoveryEventListener() {
-                @Override
-                public void onCameraFound(DiscoveredCamera discoveredCamera) {
-                    handleCameraFound(discoveredCamera);
-                }
-                
-                @Override
-                public void onDiscoveryError(CommunicationInterface iface, ErrorCode errorCode) {
-                    Log.w(TAG, "[FLIR] Emulator discovery error: " + errorCode);
-                }
-            }, CommunicationInterface.EMULATOR);
-            
-            // Short timeout for emulator
-            scheduleDiscoveryTimeout(2000);
-            
-        } catch (Throwable t) {
-            Log.e(TAG, "[FLIR] startEmulatorDiscovery failed: " + t.getMessage(), t);
-            notifyError("Emulator discovery failed: " + t.getMessage());
-        }
     }
     
-    private void handleCameraFound(DiscoveredCamera discoveredCamera) {
-        Identity identity = discoveredCamera.getIdentity();
-        String deviceId = identity.deviceId;
-        String deviceName = identity.toString();
-        CommunicationInterface iface = identity.communicationInterface;
-        boolean isEmulator = (iface == CommunicationInterface.EMULATOR);
-        
-        Log.i(TAG, "[FLIR] Camera found: " + deviceName + " (" + iface + ")");
-        logStep("DEVICE_FOUND", "id=" + deviceId + ", name=" + deviceName + ", interface=" + iface);
-        
-        CommInterface commIface;
-        switch (iface) {
-            case USB:
-                commIface = CommInterface.USB;
-                break;
-            case NETWORK:
-                commIface = CommInterface.NETWORK;
-                break;
-            default:
-                commIface = CommInterface.EMULATOR;
-        }
-        
-        DeviceInfo deviceInfo = new DeviceInfo(deviceId, deviceName, isEmulator, commIface, identity);
-        
-        // Avoid duplicates
-        boolean exists = false;
-        for (DeviceInfo d : discoveredDevices) {
-            if (d.deviceId.equals(deviceId)) {
-                exists = true;
-                break;
-            }
-        }
-        
-        if (!exists) {
-            discoveredDevices.add(deviceInfo);
-            
-            mainHandler.post(() -> {
-                if (listener != null) {
-                    listener.onDeviceFound(deviceId, deviceName, isEmulator);
-                    listener.onDeviceListUpdated(new ArrayList<>(discoveredDevices));
-                }
-            });
-            
-            // Auto-connect to first device found
-            if (discoveredDevices.size() == 1 && !isConnected.get()) {
-                cancelDiscoveryTimeout();
-                logStep("AUTO_CONNECT", "Connecting to first found device");
-                connectToIdentity(deviceInfo);
+    /**
+     * Get list of available palettes
+     */
+    public List<String> getAvailablePalettes() {
+        List<String> names = new ArrayList<>();
+        try {
+            List<Palette> palettes = PaletteManager.getDefaultPalettes();
+            for (Palette p : palettes) {
+                names.add(p.name);
             }
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting palettes", e);
         }
+        return names;
     }
     
-    private void scheduleDiscoveryTimeout(long timeoutMs) {
-        cancelDiscoveryTimeout();
-        
-        discoveryTimeoutFuture = scheduler.schedule(() -> {
-            Log.i(TAG, "[FLIR] Discovery timeout after " + timeoutMs + "ms");
-            logStep("DISCOVERY_TIMEOUT", "timeout=" + timeoutMs + "ms, devicesFound=" + discoveredDevices.size());
-            
-            isDiscovering.set(false);
-            stopDiscovery();
-            
-            mainHandler.post(() -> {
-                if (listener != null) {
-                    listener.onDiscoveryTimeout();
+    // Find palette by name
+    private Palette findPalette(String name) {
+        try {
+            List<Palette> palettes = PaletteManager.getDefaultPalettes();
+            for (Palette p : palettes) {
+                if (p.name.equalsIgnoreCase(name)) {
+                    return p;
                 }
-            });
-            
-            // If no devices found, try emulator
-            if (discoveredDevices.isEmpty() && !isEmulatorMode.get()) {
-                logStep("FALLBACK_EMULATOR", "No devices found, trying emulator");
-                startEmulatorDiscovery();
             }
-        }, timeoutMs, TimeUnit.MILLISECONDS);
-    }
-    
-    private void cancelDiscoveryTimeout() {
-        if (discoveryTimeoutFuture != null && !discoveryTimeoutFuture.isDone()) {
-            discoveryTimeoutFuture.cancel(false);
-            discoveryTimeoutFuture = null;
-        }
-    }
-    
-    // ==================== CONNECTION ====================
-    
-    private void connectToIdentity(DeviceInfo device) {
-        logStep("CONNECT_START", "device=" + device.deviceName);
-        Log.i(TAG, "[FLIR] Connecting to: " + device.deviceName);
-        
-        scheduler.execute(() -> {
-            try {
-                camera = new Camera();
-                
-                // Connect using Identity, error callback, and ConnectParameters
-                // Note: connect is blocking, so we're on a background thread
-                camera.connect(
-                    device.identity,
-                    new ConnectionStatusListener() {
-                        @Override
-                        public void onDisconnected(ErrorCode errorCode) {
-                            Log.i(TAG, "[FLIR] Disconnected: " + errorCode);
-                            logStep("DISCONNECTED", "reason=" + errorCode);
-                            
-                            isConnected.set(false);
-                            connectedDevice = null;
-                            
-                            mainHandler.post(() -> {
-                                if (listener != null) {
-                                    listener.onDeviceDisconnected();
-                                }
-                            });
-                        }
-                    },
-                    new ConnectParameters()
-                );
-                
-                // If we get here, connection succeeded
-                Log.i(TAG, "[FLIR] Connected to: " + device.deviceName);
-                logStep("CONNECTED", "device=" + device.deviceName);
-                
-                isConnected.set(true);
-                connectedDevice = device;
-                
-                mainHandler.post(() -> {
-                    if (listener != null) {
-                        listener.onDeviceConnected(device.deviceId, device.deviceName, device.isEmulator);
-                    }
-                });
-                
-                // Start streaming automatically
-                startStreaming();
-                
-            } catch (Throwable t) {
-                Log.e(TAG, "[FLIR] Connect error: " + t.getMessage(), t);
-                isConnected.set(false);
-                camera = null;
-                notifyError("Connect error: " + t.getMessage());
+            // Return first if not found
+            if (!palettes.isEmpty()) {
+                return palettes.get(0);
             }
-        });
+        } catch (Exception e) {
+            Log.e(TAG, "Error finding palette", e);
+        }
+        return null;
     }
     
-    // ==================== STREAMING ====================
-    
-    private void startStreaming() {
-        if (camera == null || !isConnected.get()) {
-            Log.w(TAG, "[FLIR] Cannot start streaming - not connected");
-            return;
-        }
-        
-        logStep("STREAM_START", "streamType=" + currentStreamKind);
-        Log.i(TAG, "[FLIR] Starting streaming...");
-        
-        scheduler.execute(() -> {
-            try {
-                // Get available streams
-                List<Stream> streams = camera.getStreams();
-                if (streams == null || streams.isEmpty()) {
-                    Log.e(TAG, "[FLIR] No streams available");
-                    notifyError("No streams available");
-                    return;
-                }
-                
-                Log.i(TAG, "[FLIR] Available streams: " + streams.size());
-                
-                // Select thermal stream (prefer thermal, fallback to first)
-                Stream thermalStream = null;
-                for (Stream s : streams) {
-                    if (s.isThermal()) {
-                        thermalStream = s;
+    // Discovery listener - no filtering, returns all devices
+    private final DiscoveryEventListener discoveryListener = new DiscoveryEventListener() {
+        @Override
+        public void onCameraFound(DiscoveredCamera discoveredCamera) {
+            Identity identity = discoveredCamera.getIdentity();
+            Log.d(TAG, "Device found: " + identity.deviceId + 
+                       " type=" + identity.communicationInterface);
+            
+            // Add to list if not already present
+            synchronized (discoveredDevices) {
+                boolean exists = false;
+                for (Identity d : discoveredDevices) {
+                    if (d.deviceId.equals(identity.deviceId)) {
+                        exists = true;
                         break;
                     }
                 }
-                currentStream = thermalStream != null ? thermalStream : streams.get(0);
-                
-                // Create ThermalStreamer for rendering
-                thermalStreamer = new ThermalStreamer(currentStream);
-                
-                // Set default palette if available
-                if (currentPalette == null) {
-                    try {
-                        List<Palette> palettes = PaletteManager.getDefaultPalettes();
-                        for (Palette p : palettes) {
-                            if (p.name.toLowerCase().contains("iron")) {
-                                currentPalette = p;
-                                break;
-                            }
-                        }
-                    } catch (Throwable t) {
-                        Log.w(TAG, "[FLIR] Failed to get default palette: " + t.getMessage());
-                    }
+                if (!exists) {
+                    discoveredDevices.add(identity);
                 }
-                
-                // Start the stream with OnReceived and OnRemoteError callbacks
-                currentStream.start(
-                    new OnReceived<Void>() {
-                        @Override
-                        public void onReceived(Void result) {
-                            // Process received frame on background thread
-                            scheduler.execute(() -> refreshThermalFrame());
-                        }
-                    },
-                    new OnRemoteError() {
-                        @Override
-                        public void onRemoteError(ErrorCode errorCode) {
-                            Log.e(TAG, "[FLIR] Stream error: " + errorCode);
-                            notifyError("Stream error: " + errorCode);
-                        }
-                    }
-                );
-                
-                isStreaming.set(true);
-                Log.i(TAG, "[FLIR] Stream started");
-                logStep("STREAM_STARTED", "stream=" + currentStream);
-                
-                mainHandler.post(() -> {
-                    if (listener != null) {
-                        listener.onStreamStarted("thermal");
-                    }
-                });
-                
-            } catch (Throwable t) {
-                Log.e(TAG, "[FLIR] Start stream error: " + t.getMessage(), t);
-                notifyError("Stream error: " + t.getMessage());
             }
-        });
-    }
-    
-    private void stopStreaming() {
-        if (currentStream != null) {
-            try {
-                currentStream.stop();
-            } catch (Throwable t) {
-                Log.w(TAG, "[FLIR] Stop stream error: " + t.getMessage());
+            
+            if (listener != null) {
+                listener.onDeviceFound(identity);
+                listener.onDeviceListUpdated(new ArrayList<>(discoveredDevices));
             }
-            currentStream = null;
-        }
-        thermalStreamer = null;
-        isStreaming.set(false);
-    }
-    
-    /**
-     * Refresh thermal frame using ThermalStreamer pattern.
-     * Called when a new frame is received.
-     */
-    private synchronized void refreshThermalFrame() {
-        if (thermalStreamer == null) {
-            return;
         }
         
-        try {
-            // Update streamer to get latest frame
-            thermalStreamer.update();
+        @Override
+        public void onCameraLost(Identity identity) {
+            Log.d(TAG, "Device lost: " + identity.deviceId);
             
-            // Get the image buffer from streamer
-            ImageBuffer imageBuffer = thermalStreamer.getImage();
-            if (imageBuffer == null) {
-                return;
+            synchronized (discoveredDevices) {
+                discoveredDevices.removeIf(d -> d.deviceId.equals(identity.deviceId));
             }
             
-            // Access thermal image safely for temperature queries and palette
-            thermalStreamer.withThermalImage(thermalImage -> {
-                // Store for temperature queries
-                currentThermalImage = thermalImage;
-                
-                // Apply palette if set
-                if (currentPalette != null) {
-                    thermalImage.setPalette(currentPalette);
-                }
-            });
-            
-            // Convert to Android Bitmap
-            Bitmap bitmap = BitmapAndroid.createBitmap(imageBuffer).getBitMap();
-            
-            if (bitmap != null) {
-                latestFrame = bitmap;
-                
-                mainHandler.post(() -> {
-                    if (listener != null) {
-                        listener.onFrame(bitmap);
-                    }
-                });
+            if (listener != null) {
+                listener.onDeviceListUpdated(new ArrayList<>(discoveredDevices));
             }
+        }
+        
+        @Override
+        public void onDiscoveryError(CommunicationInterface iface, ErrorCode error) {
+            Log.e(TAG, "Discovery error: " + iface + " - " + error);
+            notifyError("Discovery error: " + error);
+        }
+        
+        @Override
+        public void onDiscoveryFinished(CommunicationInterface iface) {
+            Log.d(TAG, "Discovery finished for: " + iface);
+        }
+    };
+    
+    // Connection status listener
+    private final ConnectionStatusListener connectionStatusListener = new ConnectionStatusListener() {
+        @Override
+        public void onDisconnected(ErrorCode error) {
+            Log.d(TAG, "Disconnected: " + (error != null ? error : "clean"));
+            camera = null;
             
-        } catch (Throwable t) {
-            Log.w(TAG, "[FLIR] refreshThermalFrame error: " + t.getMessage());
+            if (listener != null) {
+                listener.onDisconnected();
+            }
         }
-    }
+    };
     
-    // ==================== PUBLIC STOP ====================
+    // Helper to notify errors
+    private void notifyError(String message) {
+        if (listener != null) {
+            listener.onError(message);
+        }
+    }
     
     /**
-     * Stop the manager - disconnect and cleanup all resources.
+     * Cleanup resources
      */
-    public void stop() {
-        Log.i(TAG, "[FLIR] Stopping FlirSdkManager");
-        
-        // Stop streaming
-        stopStreaming();
-        
-        // Disconnect camera
+    public void destroy() {
+        stop();
         disconnect();
-        
-        // Stop discovery
-        stopDiscovery();
-        
-        // Clear state
         discoveredDevices.clear();
-        currentThermalImage = null;
-        latestFrame = null;
-        
-        Log.i(TAG, "[FLIR] FlirSdkManager stopped");
-    }
-    
-    // ==================== HELPERS ====================
-    
-    private void notifyError(String error) {
-        Log.e(TAG, "[FLIR] Error: " + error);
-        mainHandler.post(() -> {
-            if (listener != null) {
-                listener.onError(error);
-            }
-        });
+        listener = null;
+        instance = null;
+        Log.d(TAG, "Destroyed");
     }
 }