ilabs-flir 1.0.2 → 1.0.3

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

@@ -1,248 +1,254 @@
-package flir.android
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.graphics.Color
-import android.util.Base64
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.facebook.react.uimanager.ThemedReactContext
-import java.io.ByteArrayOutputStream
-import java.io.File
-import java.io.FileOutputStream
-import java.util.concurrent.atomic.AtomicLong
-
-object FlirManager {
-    private val cameraHandler: CameraHandler = CameraHandler()
-    private val lastEmitMs = AtomicLong(0)
-    private val minEmitIntervalMs = 333L // ~3 fps
-    private var discoveryStarted = false
-    private var reactContext: ThemedReactContext? = null
-    
-    // Emulator and device state tracking
-    private var isEmulatorMode = false
-    private var isPhysicalDeviceConnected = false
-    private var connectedIdentity: com.flir.thermalsdk.live.Identity? = null
-    
-    // GL texture callback support for native filters
-    interface TextureUpdateCallback {
-        fun onTextureUpdate(bitmap: Bitmap, textureUnit: Int)
-    }
-    
-    interface TemperatureCallback {
-        fun onTemperatureData(temperature: Double, x: Int, y: Int)
-    }
-    
-    private var textureCallback: TextureUpdateCallback? = null
-    private var temperatureCallback: TemperatureCallback? = null
-    private var latestBitmap: Bitmap? = null
-    
-    fun setTextureCallback(callback: TextureUpdateCallback?) {
-        textureCallback = callback
-    }
-    
-    fun setTemperatureCallback(callback: TemperatureCallback?) {
-        temperatureCallback = callback
-    }
-    
-    fun getLatestBitmap(): Bitmap? = latestBitmap
-    
-    fun getTemperatureAtPoint(x: Int, y: Int): Double? {
-        return try {
-            cameraHandler.getTemperatureAt(x, y)
-        } catch (t: Throwable) {
-            null
-        }
-    }
-    
-    /**
-     * Check if currently running in emulator mode (no physical FLIR device)
-     */
-    fun isEmulator(): Boolean = isEmulatorMode
-    
-    /**
-     * Check if a physical FLIR device is connected
-     */
-    fun isDeviceConnected(): Boolean = isPhysicalDeviceConnected
-    
-    /**
-     * Get information about the connected device
-     */
-    fun getConnectedDeviceInfo(): String {
-        return when {
-            connectedIdentity == null -> "Not connected"
-            isEmulatorMode -> "Emulator (${connectedIdentity?.deviceId})"
-            else -> "Physical device (${connectedIdentity?.deviceId})"
-        }
-    }
-
-    fun init(context: Context) {
-        try {
-            val cls = Class.forName("com.flir.thermalsdk.live.ThermalSdkAndroid")
-            val method = cls.getMethod("init", Context::class.java)
-            method.invoke(null, context.applicationContext)
-        } catch (ignored: Throwable) {
-        }
-    }
-
-    fun startDiscoveryAndConnect(context: ThemedReactContext) {
-        if (discoveryStarted) return
-        discoveryStarted = true
-        reactContext = context
-
-        emitDeviceState("discovering", false)
-
-        cameraHandler.startDiscovery(object : com.flir.thermalsdk.live.discovery.DiscoveryEventListener {
-            override fun onCameraFound(discoveredCamera: com.flir.thermalsdk.live.discovery.DiscoveredCamera) {
-                cameraHandler.add(discoveredCamera.identity)
-                
-                // Prioritize real device over emulator
-                val realDevice = cameraHandler.getFlirOne()
-                val emulatorDevice = cameraHandler.getFlirOneEmulator() ?: cameraHandler.getCppEmulator()
-                val toConnect = realDevice ?: emulatorDevice
-                
-                if (toConnect != null) {
-                    // Determine if we're connecting to emulator
-                    isEmulatorMode = (realDevice == null)
-                    isPhysicalDeviceConnected = (realDevice != null)
-                    connectedIdentity = toConnect
-                    
-                    Thread {
-                        try {
-                            cameraHandler.connect(toConnect, com.flir.thermalsdk.live.connectivity.ConnectionStatusListener { errorCode ->
-                                emitDeviceState("disconnected", false)
-                                isPhysicalDeviceConnected = false
-                                connectedIdentity = null
-                            })
-                            
-                            val deviceType = if (isEmulatorMode) "emulator" else "device"
-                            emitDeviceState("connected", true, mapOf("deviceType" to deviceType, "isEmulator" to isEmulatorMode))
-                            FlirStatus.flirConnected = true
-                            
-                            cameraHandler.startStream(object : CameraHandler.StreamDataListener {
-                                override fun images(dataHolder: FrameDataHolder) {
-                                    handleIncomingFrames(dataHolder.msxBitmap, dataHolder.dcBitmap, context)
-                                }
-
-                                override fun images(msxBitmap: Bitmap?, dcBitmap: Bitmap?) {
-                                    handleIncomingFrames(msxBitmap, dcBitmap, context)
-                                }
-                            })
-                        } catch (e: Exception) {
-                            emitDeviceState("disconnected", false)
-                            FlirStatus.flirConnected = false
-                            isPhysicalDeviceConnected = false
-                            connectedIdentity = null
-                        }
-                    }.start()
-                }
-            }
-
-            override fun onDiscoveryError(communicationInterface: com.flir.thermalsdk.live.CommunicationInterface, errorCode: com.flir.thermalsdk.ErrorCode) {
-                emitDeviceState("discovery_error", false)
-            }
-        }, object : CameraHandler.DiscoveryStatus {
-            override fun started() {}
-            override fun stopped() {}
-        })
-    }
-
-    fun stop() {
-        try {
-            cameraHandler.disconnect()
-        } catch (ignored: Throwable) {}
-        FlirStatus.flirConnected = false
-        FlirStatus.flirStreaming = false
-        discoveryStarted = false
-        reactContext = null
-    }
-
-    fun getLatestFramePath(): String? {
-        return FlirStatus.latestFramePath
-    }
-
-    fun getTemperatureAt(x: Int, y: Int): Double? {
-        return try {
-            cameraHandler.getTemperatureAt(x, y)
-        } catch (t: Throwable) {
-            null
-        }
-    }
-
-    private fun handleIncomingFrames(msxBitmap: Bitmap?, dcBitmap: Bitmap?, ctx: ThemedReactContext) {
-        val now = System.currentTimeMillis()
-        if (now - lastEmitMs.get() < minEmitIntervalMs) return
-        lastEmitMs.set(now)
-
-        val bmp = msxBitmap ?: dcBitmap ?: return
-        latestBitmap = bmp
-        
-        // Invoke texture callback for native GL/Metal filters (texture unit 7)
-        textureCallback?.onTextureUpdate(bmp, 7)
-        
-        // Get and emit temperature data
-        try {
-            val temp = cameraHandler.getTemperatureAt(80, 60) // center point
-            if (temp != null) {
-                temperatureCallback?.onTemperatureData(temp, 80, 60)
-            }
-        } catch (ignored: Throwable) {}
-
-        try {
-            val cacheDir = ctx.cacheDir
-            val outFile = File(cacheDir, "flir_latest_frame.png")
-            val fos = FileOutputStream(outFile)
-            bmp.compress(Bitmap.CompressFormat.PNG, 90, fos)
-            fos.flush()
-            fos.close()
-            FlirStatus.latestFramePath = outFile.absolutePath
-            FlirFrameCache.latestFramePath = outFile.absolutePath
-            FlirStatus.flirStreaming = true
-
-            val baos = ByteArrayOutputStream()
-            bmp.compress(Bitmap.CompressFormat.PNG, 70, baos)
-            val pngBytes = baos.toByteArray()
-            val base64 = Base64.encodeToString(pngBytes, Base64.NO_WRAP)
-
-            val params: WritableMap = Arguments.createMap().apply {
-                putString("type", "frame")
-                putString("path", outFile.absolutePath)
-                putString("base64", "data:image/png;base64," + base64)
-                putDouble("timestamp", (now / 1000.0))
-            }
-            try {
-                ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                    .emit("FlirFrame", params)
-            } catch (e: Exception) {}
-
-        } catch (e: Exception) {
-            FlirStatus.flirStreaming = false
-        }
-    }
-
-    private fun emitDeviceState(state: String, connected: Boolean, extras: Map<String, Any> = emptyMap()) {
-        FlirStatus.flirConnected = connected
-        val ctx = reactContext ?: return
-        val params: WritableMap = Arguments.createMap().apply {
-            putString("state", state)
-            putBoolean("connected", connected)
-            putString("message", if (connected) "FLIR device connected" else state)
-            
-            // Add any extra parameters
-            extras.forEach { (key, value) ->
-                when (value) {
-                    is String -> putString(key, value)
-                    is Boolean -> putBoolean(key, value)
-                    is Int -> putInt(key, value)
-                    is Double -> putDouble(key, value)
-                }
-            }
-        }
-        try {
-            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("FlirDeviceConnected", params)
-        } catch (e: Exception) {}
-    }
-}
+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.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.uimanager.ThemedReactContext
+import java.io.File
+import java.io.FileOutputStream
+import java.util.concurrent.atomic.AtomicLong
+
+object FlirManager {
+    private val TAG = "FlirManager"
+    private var sdkManager: FlirSdkManager? = null
+    private val lastEmitMs = AtomicLong(0)
+    private val minEmitIntervalMs = 333L // ~3 fps
+    private var discoveryStarted = false
+    private var reactContext: ThemedReactContext? = null
+    
+    // Emulator and device state tracking
+    private var isEmulatorMode = false
+    private var isPhysicalDeviceConnected = false
+    private var connectedDeviceName: String? = null
+    
+    // GL texture callback support for native filters
+    interface TextureUpdateCallback {
+        fun onTextureUpdate(bitmap: Bitmap, textureUnit: Int)
+    }
+    
+    interface TemperatureCallback {
+        fun onTemperatureData(temperature: Double, x: Int, y: Int)
+    }
+    
+    private var textureCallback: TextureUpdateCallback? = null
+    private var temperatureCallback: TemperatureCallback? = null
+    private var latestBitmap: Bitmap? = null
+    
+    fun setTextureCallback(callback: TextureUpdateCallback?) {
+        textureCallback = callback
+    }
+    
+    fun setTemperatureCallback(callback: TemperatureCallback?) {
+        temperatureCallback = callback
+    }
+    
+    fun getLatestBitmap(): Bitmap? = latestBitmap
+    
+    fun getTemperatureAtPoint(x: Int, y: Int): Double? {
+        return try {
+            sdkManager?.getTemperatureAtPoint(x, y)?.takeIf { !it.isNaN() }
+        } catch (t: Throwable) {
+            null
+        }
+    }
+    
+    /**
+     * Check if currently running in emulator mode (no physical FLIR device)
+     */
+    fun isEmulator(): Boolean = isEmulatorMode
+    
+    /**
+     * Check if a physical FLIR device is connected
+     */
+    fun isDeviceConnected(): Boolean = isPhysicalDeviceConnected
+    
+    /**
+     * Get information about the connected device
+     */
+    fun getConnectedDeviceInfo(): String {
+        return when {
+            connectedDeviceName == null -> "Not connected"
+            isEmulatorMode -> "Emulator ($connectedDeviceName)"
+            else -> "Physical device ($connectedDeviceName)"
+        }
+    }
+
+    fun init(context: Context) {
+        try {
+            // Initialize SDK manager with listener
+            sdkManager = FlirSdkManager(object : FlirSdkManager.Listener {
+                override fun onFrame(bitmap: Bitmap) {
+                    latestBitmap = bitmap
+                    textureCallback?.onTextureUpdate(bitmap, 0)
+                    emitFrameToReactNative(bitmap)
+                }
+
+                override fun onTemperature(temp: Double, x: Int, y: Int) {
+                    temperatureCallback?.onTemperatureData(temp, x, y)
+                }
+
+                override fun onDeviceFound(name: String) {
+                    connectedDeviceName = name
+                    isPhysicalDeviceConnected = true
+                    emitDeviceState("connected", true)
+                }
+
+                override fun onEmulatorEnabled() {
+                    isEmulatorMode = true
+                    emitDeviceState("emulator", false)
+                }
+
+                override fun onStreamKindChanged(kind: String) {
+                    Log.d(TAG, "Stream kind changed: $kind")
+                }
+            })
+            
+            // Try to initialize SDK via reflection
+            try {
+                val cls = Class.forName("com.flir.thermalsdk.live.ThermalSdkAndroid")
+                val method = cls.getMethod("init", Context::class.java)
+                method.invoke(null, context.applicationContext)
+                Log.i(TAG, "FLIR SDK initialized via reflection")
+            } catch (e: ClassNotFoundException) {
+                Log.w(TAG, "FLIR SDK not found on classpath, will attempt DexClassLoader")
+            } catch (e: Throwable) {
+                Log.w(TAG, "FLIR SDK init failed: ${e.message}")
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "FlirManager init failed", t)
+        }
+    }
+
+    fun startDiscoveryAndConnect(context: ThemedReactContext) {
+        if (discoveryStarted) return
+        discoveryStarted = true
+        reactContext = context
+
+        emitDeviceState("discovering", false)
+
+        try {
+            val started = sdkManager?.startSdkEmulator() ?: false
+            if (!started) {
+                Log.w(TAG, "Failed to start SDK emulator")
+                emitDeviceState("error", false)
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "startDiscoveryAndConnect failed", t)
+            emitDeviceState("error", false)
+        }
+    }
+
+    fun stop() {
+        discoveryStarted = false
+        isPhysicalDeviceConnected = false
+        isEmulatorMode = false
+        connectedDeviceName = null
+        latestBitmap = null
+        // Note: FlirSdkManager doesn't have a stop method, but we reset our state
+    }
+
+    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
+        }
+    }
+
+    fun getTemperatureAt(x: Int, y: Int): Double? {
+        return getTemperatureAtPoint(x, y)
+    }
+
+    private fun emitFrameToReactNative(bitmap: Bitmap) {
+        val now = System.currentTimeMillis()
+        if (now - lastEmitMs.get() < minEmitIntervalMs) return
+        lastEmitMs.set(now)
+
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap()
+            params.putInt("width", bitmap.width)
+            params.putInt("height", bitmap.height)
+            params.putDouble("timestamp", now.toDouble())
+
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirFrameReceived", params)
+        } catch (e: Exception) {
+            // Silently ignore
+        }
+    }
+
+    private fun emitDeviceState(state: String, isPhysical: Boolean) {
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap()
+            params.putString("state", state)
+            params.putBoolean("isPhysical", isPhysical)
+            params.putBoolean("isEmulator", isEmulatorMode)
+            params.putBoolean("isConnected", isPhysicalDeviceConnected)
+            
+            connectedDeviceName?.let {
+                params.putString("deviceName", it)
+            }
+
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirDeviceConnected", params)
+        } catch (e: Exception) {}
+    }
+
+    // Compatibility for Java / FlirHelper
+    @JvmStatic
+    fun getInstance(): FlirManager = this
+
+    interface DiscoveryCallback {
+        fun onDeviceFound(deviceName: String)
+        fun onDiscoveryTimeout()
+        fun onEmulatorEnabled()
+    }
+
+    private var discoveryCallback: DiscoveryCallback? = null
+
+    fun setDiscoveryCallback(callback: DiscoveryCallback?) {
+        discoveryCallback = callback
+    }
+
+    fun setPalette(name: String) {
+        sdkManager?.setPalette(name)
+    }
+
+    fun setEmulatorMode(enabled: Boolean) {
+        isEmulatorMode = enabled
+        if (enabled) {
+             discoveryCallback?.onEmulatorEnabled()
+        }
+    }
+
+    fun updateAcol(value: Float) {
+        // No-op for now - palette changes handled by setPalette
+    }
+
+    fun startDiscovery(retry: Boolean) {
+        if (reactContext != null) {
+            startDiscoveryAndConnect(reactContext!!)
+        } else {
+            // Fallback: try to start without React context
+            try {
+                sdkManager?.startSdkEmulator()
+            } catch (t: Throwable) {
+                Log.e(TAG, "startDiscovery failed", t)
+            }
+        }
+    }
+    
+    fun enableEmulatorMode() {
+        setEmulatorMode(true)
+    }
+}