ilabs-flir 2.3.7 → 2.3.10

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

@@ -1,521 +1,465 @@
-package flir.android
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.util.Log
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.facebook.react.uimanager.ThemedReactContext
-import com.flir.thermalsdk.live.Identity
-import com.flir.thermalsdk.image.Palette
-import com.flir.thermalsdk.image.PaletteManager
-import java.io.File
-import java.io.FileOutputStream
-import java.util.concurrent.atomic.AtomicLong
-
-/**
- * Simplified FlirManager - bridge between React Native and FlirSdkManager
- * Matches the simplified pattern: scan -> connect -> stream -> disconnect
- */
-object FlirManager {
-    private const val TAG = "FlirManager"
-    
-    private var sdkManager: FlirSdkManager? = null
-    private var reactContext: ReactContext? = null
-    
-    // Frame rate limiting for RN events
-    private val lastEmitMs = AtomicLong(0)
-    private val minEmitIntervalMs = 100L // ~10 fps max for RN events
-    
-    // Cached palette list to avoid repeated JNI calls (especially if linkage is unstable)
-    private var cachedPalettes: List<*>? = null
-    private var cachedPaletteNames: List<String>? = null
-    
-    // State
-    private var isInitialized = false
-    private var isScanning = false
-    private var isConnected = false
-    private var isStreaming = false
-    private var connectedDeviceId: String? = null
-    private var connectedDeviceName: String? = null
-
-    // Concurrency control
-    private val shouldProcessFrames = java.util.concurrent.atomic.AtomicBoolean(false)
-    private val isUpdatingTexture = java.util.concurrent.atomic.AtomicBoolean(false)
-    
-    // Latest bitmap
-    private var latestBitmap: Bitmap? = null
-    
-    // Callbacks
-    interface TextureUpdateCallback {
-        fun onTextureUpdate(bitmap: Bitmap, textureUnit: Int)
-    }
-    
-    private var textureCallback: TextureUpdateCallback? = null
-    
-    fun setTextureCallback(callback: TextureUpdateCallback?) {
-        textureCallback = callback
-    }
-
-    interface TemperatureUpdateCallback {
-        fun onTemperatureUpdate(temperature: Double)
-    }
-
-    private var temperatureCallback: TemperatureUpdateCallback? = null
-
-    fun setTemperatureCallback(callback: TemperatureUpdateCallback?) {
-        temperatureCallback = callback
-    }
-    
-    fun getLatestBitmap(): Bitmap? = latestBitmap
-
-    // Stubs for removed features
-    fun setPreferSdkRotation(prefer: Boolean) { /* No-op */ }
-    fun isPreferSdkRotation(): Boolean = false
-    fun getBatteryLevel(): Int = -1
-    fun isBatteryCharging(): Boolean = false
-    fun setPalette(name: String) {
-        sdkManager?.setPalette(name)
-        // Also try to update the app's global Var.cool if possible
-        try {
-            val palettes = getAvailablePalettes()
-            val idx = palettes.indexOf(name.lowercase())
-            if (idx != -1) {
-                updateAcol(idx.toFloat())
-            }
-        } catch (e: Exception) {}
-    }
-    fun getAvailablePalettes(): List<String> {
-        return try {
-            val palettes = PaletteManager.getDefaultPalettes().map { it.name }.toMutableList()
-            // Move WhiteHot/Gray to the front
-            val grayIdx = palettes.indexOfFirst { 
-                it.equals("WhiteHot", ignoreCase = true) || it.equals("Gray", ignoreCase = true) || it.contains("gray", ignoreCase = true) 
-            }
-            if (grayIdx > 0) {
-                val gray = palettes.removeAt(grayIdx)
-                palettes.add(0, gray)
-            }
-            palettes
-        } catch (t: Throwable) {
-            Log.e(TAG, "Failed to get available palettes from SDK", t)
-            listOf("grayscale", "iron", "rainbow", "arctic", "lava", "contrast", "hotcold", "medical")
-        }
-    }
-    
-    /**
-     * Initialize the FLIR SDK
-     */
-    fun init(context: Context) {
-        if (context is ReactContext) {
-            reactContext = context
-        }
-        
-        if (isInitialized) return
-        
-        sdkManager = FlirSdkManager.getInstance(context)
-        sdkManager?.setListener(sdkListener)
-        sdkManager?.initialize()
-        
-        isInitialized = true
-        Log.i(TAG, "FlirManager initialized")
-        
-        // Generate palette icons on background thread
-        Thread {
-            try {
-                generatePaletteIcons(context)
-            } catch (e: Exception) {
-                Log.e(TAG, "Initial palette icon generation failed", e)
-            }
-        }.start()
-    }
-    
-    /**
-     * Start scanning
-     */
-    @Synchronized
-    fun startDiscovery(retry: Boolean = false) {
-        if (!isInitialized && reactContext != null) {
-            init(reactContext!!)
-        }
-        
-        if (isScanning && !retry) return
-        
-        Log.i(TAG, "Starting FlirManager discovery...")
-        isScanning = true
-        emitDeviceState("discovering")
-        sdkManager?.scan()
-    }
-    
-    /**
-     * Start discovery with React context
-     */
-    fun startDiscoveryAndConnect(context: ThemedReactContext, isEmuMode: Boolean = false) {
-        reactContext = context
-        startDiscovery(retry = false)
-    }
-    
-    /**
-     * Stop scanning
-     */
-    @Synchronized
-    fun stopDiscovery() {
-        Log.i(TAG, "Stopping FlirManager discovery...")
-        sdkManager?.stopScan()
-        isScanning = false
-    }
-    
-    /**
-     * Connect to a device
-     */
-    @Synchronized
-    fun connectToDevice(deviceId: String?) {
-        if (deviceId == null) {
-            Log.e(TAG, "connectToDevice: deviceId is null")
-            return
-        }
-        Log.i(TAG, "connectToDevice: $deviceId")
-        
-        val devices = sdkManager?.discoveredDevices ?: emptyList()
-        val identity = devices.find { it.deviceId == deviceId }
-        
-        if (identity != null) {
-            shouldProcessFrames.set(true)
-            sdkManager?.connect(identity)
-        } else {
-            Log.e(TAG, "Device not found: $deviceId")
-            emitError("Device not found: $deviceId")
-        }
-    }
-
-    fun switchToDevice(deviceId: String) {
-        connectToDevice(deviceId)
-    }
-    
-    /**
-     * Disconnect
-     */
-    @Synchronized
-    fun disconnect() {
-        Log.i(TAG, "Disconnecting FlirManager...")
-        shouldProcessFrames.set(false)
-        sdkManager?.disconnect()
-        isConnected = false
-        isStreaming = false
-        connectedDeviceId = null
-        connectedDeviceName = null
-    }
-    
-    /**
-     * Stop everything
-     */
-    @Synchronized
-    fun stop() {
-        Log.i(TAG, "Stopping FlirManager completely...")
-        shouldProcessFrames.set(false)
-        
-        // Clear callbacks first to prevent any more frames/updates from hitting Java/RN
-        textureCallback = null
-        temperatureCallback = null
-        
-        disconnect()
-        stopDiscovery()
-        latestBitmap = null
-        Log.i(TAG, "FlirManager stopped")
-    }
-    
-    // Stub legacy methods
-    fun startStream() { /* handled automatically by connect */ }
-    fun stopStream() { sdkManager?.stopStream() }
-    
-    /**
-     * Get temperature
-     */
-    fun getTemperatureAt(x: Int, y: Int): Double? {
-        val temp = sdkManager?.getTemperatureAt(x, y)
-        return if (temp != null && !temp.isNaN()) temp else null
-    }
-    
-    fun getTemperatureAtNormalized(nx: Double, ny: Double): Double? {
-        val bitmap = latestBitmap ?: return null
-        val px = (nx * bitmap.width).toInt().coerceIn(0, bitmap.width - 1)
-        val py = (ny * bitmap.height).toInt().coerceIn(0, bitmap.height - 1)
-        return getTemperatureAt(px, py)
-    }
-    
-    fun getTemperatureAtPoint(x: Int, y: Int): Double? = getTemperatureAt(x, y)
-    
-    /**
-     * Get discovered devices
-     */
-    fun getDiscoveredDevices(): List<Identity> {
-        return sdkManager?.discoveredDevices ?: emptyList()
-    }
-    
-    /**
-     * Check states
-     */
-    fun isConnected(): Boolean = isConnected
-    fun isStreaming(): Boolean = isStreaming
-    fun isEmulator(): Boolean = connectedDeviceName?.contains("EMULAT", ignoreCase = true) == true
-    fun isDeviceConnected(): Boolean = isConnected
-    
-    fun getConnectedDeviceInfo(): String {
-        return connectedDeviceName ?: "Not connected"
-    }
-    
-     /**
-     * Capture a high-fidelity radiometric snapshot (saves thermal data)
-     */
-    fun captureRadiometricSnapshot(path: String, callback: FlirSdkManager.SnapshotCallback? = null) {
-        sdkManager?.captureRadiometricSnapshot(path, callback)
-    }
-
-    /**
-     * Get latest frame as file path (for RN)
-     */
-    fun getLatestFramePath(): String? {
-        val bitmap = latestBitmap ?: return null
-        return try {
-            val file = File.createTempFile("flir_frame_", ".jpg")
-            FileOutputStream(file).use { out ->
-                bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out)
-            }
-            file.absolutePath
-        } catch (t: Throwable) {
-            null
-        }
-    }
-    
-    // SDK Listener
-    private val sdkListener = object : FlirSdkManager.Listener {
-        override fun onDeviceFound(identity: Identity) {
-            // Devices updated event handles the list, but we can log unique finds
-        }
-        
-        override fun onDeviceListUpdated(devices: List<Identity>) {
-            Log.d(TAG, "Devices found: ${devices.size}")
-            emitDevicesFound(devices)
-        }
-        
-        override fun onConnected(identity: Identity) {
-            Log.i(TAG, "Connected to: ${identity.deviceId}")
-            isConnected = true
-            connectedDeviceId = identity.deviceId
-            connectedDeviceName = identity.deviceId
-            emitDeviceState("connected")
-        }
-        
-        override fun onDisconnected() {
-            Log.i(TAG, "Disconnected")
-            isConnected = false
-            isStreaming = false
-            connectedDeviceId = null
-            connectedDeviceName = null
-            emitDeviceState("disconnected")
-        }
-        
-        override fun onFrame(bitmap: Bitmap) {
-            // IMMEDIATE STOP CHECK
-            if (!shouldProcessFrames.get()) {
-                return
-            }
-
-            // THROTTLE: Limit to ~30 FPS for smoother streaming
-            val now = System.currentTimeMillis()
-            if (now - lastEmitMs.get() < 33) { // 33ms ~= 30 FPS
-                return
-            }
-            lastEmitMs.set(now)
-
-            latestBitmap = bitmap
-            
-            // If this is the first frame, notify JS that we are now streaming
-            if (!isStreaming) {
-                isStreaming = true
-                emitDeviceState("streaming")
-            }
-            
-            // NON-BLOCKING TEXTURE UPDATE
-            if (textureCallback != null) {
-                // We use try-lock to ensure we don't pile up parallel calls, 
-                // though usually onFrame is serial. 
-                if (isUpdatingTexture.compareAndSet(false, true)) {
-                    try {
-                        textureCallback?.onTextureUpdate(bitmap, 0)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Texture update failed", e)
-                    } finally {
-                        isUpdatingTexture.set(false)
-                    }
-                }
-            }
-            
-            // Notify RN - disabled
-            // emitFrameToReactNative(bitmap)
-        }
-        
-        override fun onError(message: String) {
-            emitError(message)
-        }
-    }
-    
-    // React Native Emitters
-    
-    private fun emitFrameToReactNative(bitmap: Bitmap) {
-        // PERF: Disabled to reduce bridge traffic
-        /*
-        val now = System.currentTimeMillis()
-        if (now - lastEmitMs.get() < minEmitIntervalMs) return
-        lastEmitMs.set(now)
-        
-        val ctx = reactContext ?: return
-        try {
-            val params = Arguments.createMap().apply {
-                putInt("width", bitmap.width)
-                putInt("height", bitmap.height)
-                putDouble("timestamp", now.toDouble())
-            }
-            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("FlirFrameReceived", params)
-        } catch (e: Exception) { }
-        */
-    }
-    
-    private fun emitDeviceState(state: String) {
-        val ctx = reactContext ?: return
-        try {
-            val params = Arguments.createMap().apply {
-                putString("state", state)
-                putBoolean("isConnected", isConnected)
-                putBoolean("isStreaming", isStreaming)
-                putBoolean("isEmulator", isEmulator())
-                connectedDeviceName?.let { putString("deviceName", it) }
-            }
-            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("FlirDeviceConnected", params)
-        } catch (e: Exception) { }
-    }
-    
-    private fun emitDevicesFound(devices: List<Identity>) {
-        val ctx = reactContext ?: return
-        try {
-            val params = Arguments.createMap()
-            val devicesArray: WritableArray = Arguments.createArray()
-            
-            devices.forEach { identity ->
-                val deviceMap = Arguments.createMap().apply {
-                    putString("id", identity.deviceId)
-                    putString("name", identity.deviceId)
-                    putString("communicationType", identity.communicationInterface.name)
-                    putBoolean("isEmulator", identity.communicationInterface.name == "EMULATOR")
-                }
-                devicesArray.pushMap(deviceMap)
-            }
-            
-            params.putArray("devices", devicesArray)
-            params.putInt("count", devices.size)
-            
-            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("FlirDevicesFound", params)
-        } catch (e: Exception) { }
-    }
-    
-    private fun emitError(message: String) {
-        val ctx = reactContext ?: return
-        try {
-            val params = Arguments.createMap().apply {
-                putString("error", message)
-                putString("message", message)
-            }
-            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("FlirError", params)
-        } catch (e: Exception) { }
-    }
-    
-    // Legacy methods placeholders
-    @JvmStatic fun getInstance(): FlirManager = this
-    
-    interface DiscoveryCallback {
-        fun onDeviceFound(deviceName: String)
-        fun onDiscoveryTimeout()
-        fun onEmulatorEnabled()
-    }
-    fun setDiscoveryCallback(callback: DiscoveryCallback?) { /* No-op */ }
-    fun setEmulatorMode(enabled: Boolean) { startDiscovery() }
-    fun enableEmulatorMode() = startDiscovery()
-    fun forceEmulatorMode(type: String = "FLIR_ONE_EDGE") { startDiscovery() }
-    fun setPreferredEmulatorType(type: String) { }
-    fun updateAcol(value: Float) {
-        Log.d(TAG, "updateAcol: $value")
-        // Use reflection to update ilabs.libs.io.data.Var.cool to avoid circular dependency
-        try {
-            val varClass = Class.forName("ilabs.libs.io.data.Var")
-            val coolField = varClass.getField("cool")
-            
-            // Modular logic for palettes: if index > 7, wrap around (17 mod 8)
-            // But we keep shader variants (14, 15, 16) as-is if within that range
-            val rawIdx = value.toInt()
-            var shaderIdx = rawIdx
-            if (shaderIdx > 16) {
-                shaderIdx = shaderIdx % 16 // Shader loop
-            }
-            
-            coolField.set(null, shaderIdx)
-            Log.d(TAG, "Updated Var.cool to $shaderIdx via reflection (raw=$rawIdx)")
-
-            // Standard FLIR palette list from samples
-            val paletteNames = listOf("Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel")
-            Log.d(TAG, "Using hardcoded FLIR Palettes: $paletteNames")
-            
-            val maxEff = paletteNames.size
-            val paletteIdx = rawIdx % maxEff
-            val safeIdx = if (paletteIdx < 0) paletteIdx + maxEff else paletteIdx
-            
-            val targetPaletteName = paletteNames[safeIdx]
-            Log.d(TAG, "Applying FLIR palette: $targetPaletteName (index: $safeIdx, max: $maxEff)")
-            
-            sdkManager?.setPalette(targetPaletteName)
-            
-        } catch (e: Throwable) {
-            Log.w(TAG, "Could not update Var.cool via reflection: ${e.message}")
-        }
-    }
-
-    /**
-     * Generate icons for all default palettes and save to cache.
-     */
-    fun generatePaletteIcons(context: Context): List<Map<String, String>> {
-        val results = mutableListOf<Map<String, String>>()
-        try {
-            // Standard FLIR palette list from samples
-            val paletteNames = listOf("Gray", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel")
-            
-            val dir = File(context.cacheDir, "flir_palettes")
-            if (!dir.exists()) dir.mkdirs()
-
-            for (name in paletteNames) {
-                val iconFile = File(dir, "${name.lowercase()}.png")
-                // Note: We'll rely on the app to provide these icons or they will be generated by the SDK if possible.
-                // For now, we return the names and the cache path.
-                results.add(mapOf(
-                    "name" to name,
-                    "uri" to if (iconFile.exists()) "file://${iconFile.absolutePath}" else ""
-                ))
-            }
-        } catch (t: Throwable) {
-            Log.e(TAG, "Palette icon list generation error", t)
-        }
-        return results
-    }
-
-    fun getPalettesWithIcons(context: Context? = null): List<Map<String, String>> {
-        val ctx = context ?: reactContext ?: return emptyList()
-        return generatePaletteIcons(ctx)
-    }
-
-    fun destroy() { stop() }
-}
+package flir.android
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.flir.thermalsdk.live.Identity
+import com.flir.thermalsdk.image.Palette
+import com.flir.thermalsdk.image.PaletteManager
+import java.io.File
+import java.io.FileOutputStream
+import java.util.concurrent.atomic.AtomicLong
+
+/**
+ * Simplified FlirManager - bridge between React Native and FlirSdkManager
+ * Matches the simplified pattern: scan -> connect -> stream -> disconnect
+ */
+object FlirManager {
+    private const val TAG = "FlirManager"
+    
+    private var sdkManager: FlirSdkManager? = null
+    private var reactContext: ReactContext? = null
+    
+    // Frame rate limiting for RN events
+    private val lastEmitMs = AtomicLong(0)
+    private val minEmitIntervalMs = 100L // ~10 fps max for RN events
+    
+    // Cached palette list to avoid repeated JNI calls (especially if linkage is unstable)
+    private var cachedPalettes: List<*>? = null
+    private var cachedPaletteNames: List<String>? = null
+    
+    // Cached reflection for performance
+    private var coolField: java.lang.reflect.Field? = null
+    
+    // State
+    private var isInitialized = false
+    private var isScanning = false
+    private var isConnected = false
+    private var isStreaming = false
+    private var connectedDeviceId: String? = null
+    private var connectedDeviceName: String? = null
+
+    // Concurrency control
+    private val shouldProcessFrames = java.util.concurrent.atomic.AtomicBoolean(false)
+    private val isUpdatingTexture = java.util.concurrent.atomic.AtomicBoolean(false)
+    
+    // Latest bitmap
+    private var latestBitmap: Bitmap? = null
+    
+    // Callbacks
+    interface TextureUpdateCallback {
+        fun onTextureUpdate(bitmap: Bitmap, textureUnit: Int)
+    }
+    
+    private var textureCallback: TextureUpdateCallback? = null
+    
+    fun setTextureCallback(callback: TextureUpdateCallback?) {
+        textureCallback = callback
+    }
+
+    interface TemperatureUpdateCallback {
+        fun onTemperatureUpdate(temperature: Double)
+    }
+
+    private var temperatureCallback: TemperatureUpdateCallback? = null
+
+    fun setTemperatureCallback(callback: TemperatureUpdateCallback?) {
+        temperatureCallback = callback
+    }
+    
+    fun getLatestBitmap(): Bitmap? = latestBitmap
+
+    // Stubs for removed features
+    fun setPreferSdkRotation(prefer: Boolean) { /* No-op */ }
+    fun isPreferSdkRotation(): Boolean = false
+    fun getBatteryLevel(): Int = -1
+    fun isBatteryCharging(): Boolean = false
+    
+    fun setPalette(name: String) {
+        sdkManager?.setPalette(name)
+        // Also try to update the app's global Var.cool if possible
+        try {
+            val palettes = getAvailablePalettes()
+            val idx = palettes.indexOfFirst { it.equals(name, ignoreCase = true) }
+            if (idx != -1) {
+                updateAcol(idx.toFloat())
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "setPalette: Failed to update Var.cool", e)
+        }
+    }
+    
+    fun getAvailablePalettes(): List<String> {
+        // Return hardcoded list to avoid PaletteManager class-loading crashes
+        // and ensure maximum performance. Matches standard FLIR and shader palettes.
+        return listOf("WhiteHot", "Iron", "Rainbow", "Arctic", "Lava", "Coldest", "Hottest", "Wheel")
+    }
+    
+    /**
+     * Initialize the FLIR SDK
+     */
+    fun init(context: Context) {
+        if (context is ReactContext) {
+            reactContext = context
+        }
+        
+        if (isInitialized) return
+        
+        sdkManager = FlirSdkManager.getInstance(context)
+        sdkManager?.setListener(sdkListener)
+        sdkManager?.initialize()
+        
+        isInitialized = true
+        Log.i(TAG, "FlirManager initialized")
+    }
+    
+    /**
+     * Start scanning
+     */
+    @Synchronized
+    fun startDiscovery(retry: Boolean = false) {
+        if (!isInitialized && reactContext != null) {
+            init(reactContext!!)
+        }
+        
+        if (isScanning && !retry) return
+        
+        Log.i(TAG, "Starting FlirManager discovery...")
+        isScanning = true
+        emitDeviceState("discovering")
+        sdkManager?.scan()
+    }
+    
+    /**
+     * Start discovery with React context
+     */
+    fun startDiscoveryAndConnect(context: ThemedReactContext, isEmuMode: Boolean = false) {
+        reactContext = context
+        startDiscovery(retry = false)
+    }
+    
+    /**
+     * Stop scanning
+     */
+    @Synchronized
+    fun stopDiscovery() {
+        Log.i(TAG, "Stopping FlirManager discovery...")
+        sdkManager?.stopScan()
+        isScanning = false
+    }
+    
+    /**
+     * Connect to a device
+     */
+    @Synchronized
+    fun connectToDevice(deviceId: String?) {
+        if (deviceId == null) {
+            Log.e(TAG, "connectToDevice: deviceId is null")
+            return
+        }
+        Log.i(TAG, "connectToDevice: $deviceId")
+        
+        val devices = sdkManager?.discoveredDevices ?: emptyList()
+        val identity = devices.find { it.deviceId == deviceId }
+        
+        if (identity != null) {
+            shouldProcessFrames.set(true)
+            sdkManager?.connect(identity)
+        } else {
+            Log.e(TAG, "Device not found: $deviceId")
+            emitError("Device not found: $deviceId")
+        }
+    }
+
+    fun switchToDevice(deviceId: String) {
+        connectToDevice(deviceId)
+    }
+    
+    /**
+     * Disconnect
+     */
+    @Synchronized
+    fun disconnect() {
+        Log.i(TAG, "Disconnecting FlirManager...")
+        shouldProcessFrames.set(false)
+        sdkManager?.disconnect()
+        isConnected = false
+        isStreaming = false
+        connectedDeviceId = null
+        connectedDeviceName = null
+    }
+    
+    /**
+     * Stop everything
+     */
+    @Synchronized
+    fun stop() {
+        Log.i(TAG, "Stopping FlirManager completely...")
+        shouldProcessFrames.set(false)
+        
+        // Clear callbacks first to prevent any more frames/updates from hitting Java/RN
+        textureCallback = null
+        temperatureCallback = null
+        
+        disconnect()
+        stopDiscovery()
+        latestBitmap = null
+        Log.i(TAG, "FlirManager stopped")
+    }
+    
+    // Stub legacy methods
+    fun startStream() { /* handled automatically by connect */ }
+    fun stopStream() { sdkManager?.stopStream() }
+    
+    /**
+     * Get temperature
+     */
+    fun getTemperatureAt(x: Int, y: Int): Double? {
+        val temp = sdkManager?.getTemperatureAt(x, y)
+        return if (temp != null && !temp.isNaN()) temp else null
+    }
+    
+    fun getTemperatureAtNormalized(nx: Double, ny: Double): Double? {
+        val bitmap = latestBitmap ?: return null
+        val px = (nx * bitmap.width).toInt().coerceIn(0, bitmap.width - 1)
+        val py = (ny * bitmap.height).toInt().coerceIn(0, bitmap.height - 1)
+        return getTemperatureAt(px, py)
+    }
+    
+    fun getTemperatureAtPoint(x: Int, y: Int): Double? = getTemperatureAt(x, y)
+    
+    /**
+     * Get discovered devices
+     */
+    fun getDiscoveredDevices(): List<Identity> {
+        return sdkManager?.discoveredDevices ?: emptyList()
+    }
+    
+    /**
+     * Check states
+     */
+    fun isConnected(): Boolean = isConnected
+    fun isStreaming(): Boolean = isStreaming
+    fun isEmulator(): Boolean = connectedDeviceName?.contains("EMULAT", ignoreCase = true) == true
+    fun isDeviceConnected(): Boolean = isConnected
+    
+    fun getConnectedDeviceInfo(): String {
+        return connectedDeviceName ?: "Not connected"
+    }
+    
+     /**
+     * Capture a high-fidelity radiometric snapshot (saves thermal data)
+     */
+    fun captureRadiometricSnapshot(path: String, callback: FlirSdkManager.SnapshotCallback? = null) {
+        sdkManager?.captureRadiometricSnapshot(path, callback)
+    }
+
+    /**
+     * Get latest frame as file path (for RN)
+     */
+    fun getLatestFramePath(): String? {
+        val bitmap = latestBitmap ?: return null
+        return try {
+            val file = File.createTempFile("flir_frame_", ".jpg")
+            FileOutputStream(file).use { out ->
+                bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out)
+            }
+            file.absolutePath
+        } catch (t: Throwable) {
+            null
+        }
+    }
+    
+    // SDK Listener
+    private val sdkListener = object : FlirSdkManager.Listener {
+        override fun onDeviceFound(identity: Identity) {
+            // Devices updated event handles the list, but we can log unique finds
+        }
+        
+        override fun onDeviceListUpdated(devices: List<Identity>) {
+            Log.d(TAG, "Devices found: ${devices.size}")
+            emitDevicesFound(devices)
+        }
+        
+        override fun onConnected(identity: Identity) {
+            Log.i(TAG, "Connected to: ${identity.deviceId}")
+            isConnected = true
+            connectedDeviceId = identity.deviceId
+            connectedDeviceName = identity.deviceId
+            emitDeviceState("connected")
+        }
+        
+        override fun onDisconnected() {
+            Log.i(TAG, "Disconnected")
+            isConnected = false
+            isStreaming = false
+            connectedDeviceId = null
+            connectedDeviceName = null
+            emitDeviceState("disconnected")
+        }
+        
+        override fun onFrame(bitmap: Bitmap) {
+            // IMMEDIATE STOP CHECK
+            if (!shouldProcessFrames.get()) {
+                return
+            }
+
+            // THROTTLE: Limit to ~30 FPS for smoother streaming
+            val now = System.currentTimeMillis()
+            if (now - lastEmitMs.get() < 33) { // 33ms ~= 30 FPS
+                return
+            }
+            lastEmitMs.set(now)
+
+            latestBitmap = bitmap
+            
+            // If this is the first frame, notify JS that we are now streaming
+            if (!isStreaming) {
+                isStreaming = true
+                emitDeviceState("streaming")
+            }
+            
+            // NON-BLOCKING TEXTURE UPDATE
+            if (textureCallback != null) {
+                // We use try-lock to ensure we don't pile up parallel calls, 
+                // though usually onFrame is serial. 
+                if (isUpdatingTexture.compareAndSet(false, true)) {
+                    try {
+                        textureCallback?.onTextureUpdate(bitmap, 0)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Texture update failed", e)
+                    } finally {
+                        isUpdatingTexture.set(false)
+                    }
+                }
+            }
+        }
+        
+        override fun onError(message: String) {
+            emitError(message)
+        }
+    }
+    
+    // React Native Emitters
+    
+    private fun emitDeviceState(state: String) {
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap().apply {
+                putString("state", state)
+                putBoolean("isConnected", isConnected)
+                putBoolean("isStreaming", isStreaming)
+                putBoolean("isEmulator", isEmulator())
+                connectedDeviceName?.let { putString("deviceName", it) }
+            }
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirDeviceConnected", params)
+        } catch (e: Exception) { }
+    }
+    
+    private fun emitDevicesFound(devices: List<Identity>) {
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap()
+            val devicesArray: WritableArray = Arguments.createArray()
+            
+            devices.forEach { identity ->
+                val deviceMap = Arguments.createMap().apply {
+                    putString("id", identity.deviceId)
+                    putString("name", identity.deviceId)
+                    putString("communicationType", identity.communicationInterface.name)
+                    putBoolean("isEmulator", identity.communicationInterface.name == "EMULATOR")
+                }
+                devicesArray.pushMap(deviceMap)
+            }
+            
+            params.putArray("devices", devicesArray)
+            params.putInt("count", devices.size)
+            
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirDevicesFound", params)
+        } catch (e: Exception) { }
+    }
+    
+    private fun emitError(message: String) {
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap().apply {
+                putString("error", message)
+                putString("message", message)
+            }
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirError", params)
+        } catch (e: Exception) { }
+    }
+    
+    // Legacy methods placeholders
+    @JvmStatic fun getInstance(): FlirManager = this
+    
+    interface DiscoveryCallback {
+        fun onDeviceFound(deviceName: String)
+        fun onDiscoveryTimeout()
+        fun onEmulatorEnabled()
+    }
+    fun setDiscoveryCallback(callback: DiscoveryCallback?) { /* No-op */ }
+    fun setEmulatorMode(enabled: Boolean) { startDiscovery() }
+    fun enableEmulatorMode() = startDiscovery()
+    fun forceEmulatorMode(type: String = "FLIR_ONE_EDGE") { startDiscovery() }
+    fun setPreferredEmulatorType(type: String) { }
+    fun updateAcol(value: Float) {
+        try {
+            if (coolField == null) {
+                val varClass = Class.forName("ilabs.libs.io.data.Var")
+                coolField = varClass.getField("cool")
+            }
+            
+            val rawIdx = value.toInt()
+            var shaderIdx = rawIdx
+            if (shaderIdx > 16) {
+                shaderIdx = shaderIdx % 16 // Shader loop
+            }
+            
+            coolField?.set(null, shaderIdx)
+
+            // Standard FLIR palette list
+            val paletteNames = getAvailablePalettes()
+            val maxEff = paletteNames.size
+            val paletteIdx = rawIdx % maxEff
+            val safeIdx = if (paletteIdx < 0) paletteIdx + maxEff else paletteIdx
+            
+            val targetPaletteName = paletteNames[safeIdx]
+            sdkManager?.setPalette(targetPaletteName)
+            
+        } catch (e: Throwable) {
+            Log.w(TAG, "updateAcol reflection failed: ${e.message}")
+        }
+    }
+
+    /**
+     * Generate icons for all default palettes and save to cache.
+     */
+    fun generatePaletteIcons(context: Context): List<Map<String, String>> {
+        val results = mutableListOf<Map<String, String>>()
+        val paletteNames = getAvailablePalettes()
+        for (name in paletteNames) {
+            results.add(mapOf(
+                "name" to name,
+                "uri" to "" // No URI - rely on local assets if any
+            ))
+        }
+        return results
+    }
+
+    fun getPalettesWithIcons(context: Context? = null): List<Map<String, String>> {
+        val ctx = context ?: reactContext ?: return emptyList()
+        return generatePaletteIcons(ctx)
+    }
+
+    fun destroy() { stop() }
+}