ilabs-flir 1.0.3 → 1.0.5

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

@@ -4,6 +4,7 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.util.Log
 import com.facebook.react.bridge.Arguments
+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
@@ -13,16 +14,27 @@ import java.util.concurrent.atomic.AtomicLong
 
 object FlirManager {
     private val TAG = "FlirManager"
+    private val FLOW_TAG = "FLIR_FLOW"  // Matching FlirSdkManager flow tag
     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
+    private var appContext: Context? = null
+    private var frameCount = 0  // For tracking first frame
     
     // Emulator and device state tracking
     private var isEmulatorMode = false
     private var isPhysicalDeviceConnected = false
     private var connectedDeviceName: String? = null
+    private var connectedDeviceId: String? = null
+    private var isStreaming = false
+    
+    // Current emulator type preference
+    private var preferredEmulatorType = FlirSdkManager.EmulatorType.FLIR_ONE_EDGE
+    
+    // Discovered devices cache
+    private var discoveredDevices: List<FlirSdkManager.DeviceInfo> = emptyList()
     
     // GL texture callback support for native filters
     interface TextureUpdateCallback {
@@ -63,7 +75,17 @@ object FlirManager {
     /**
      * Check if a physical FLIR device is connected
      */
-    fun isDeviceConnected(): Boolean = isPhysicalDeviceConnected
+    fun isDeviceConnected(): Boolean = isPhysicalDeviceConnected || isEmulatorMode
+    
+    /**
+     * Check if currently streaming
+     */
+    fun isStreaming(): Boolean = isStreaming
+    
+    /**
+     * Get list of discovered devices
+     */
+    fun getDiscoveredDevices(): List<FlirSdkManager.DeviceInfo> = discoveredDevices
     
     /**
      * Get information about the connected device
@@ -75,13 +97,37 @@ object FlirManager {
             else -> "Physical device ($connectedDeviceName)"
         }
     }
+    
+    /**
+     * Set preferred emulator type (FLIR_ONE_EDGE or FLIR_ONE)
+     */
+    fun setPreferredEmulatorType(type: String) {
+        preferredEmulatorType = when (type.uppercase()) {
+            "FLIR_ONE" -> FlirSdkManager.EmulatorType.FLIR_ONE
+            else -> FlirSdkManager.EmulatorType.FLIR_ONE_EDGE
+        }
+        Log.d(TAG, "Preferred emulator type set to: $preferredEmulatorType")
+        sdkManager?.setEmulatorType(preferredEmulatorType)
+    }
 
     fun init(context: Context) {
+        // Avoid re-initialization if already done
+        if (sdkManager != null) {
+            Log.i(FLOW_TAG, "[FlirManager] init() called but already initialized, skipping")
+            return
+        }
+        
+        appContext = context.applicationContext
+        Log.i(FLOW_TAG, "[FlirManager] init() called - initializing SDK Manager")
         try {
-            // Initialize SDK manager with listener
+            // Initialize SDK manager with listener matching FlirSdkManager.Listener interface
             sdkManager = FlirSdkManager(object : FlirSdkManager.Listener {
                 override fun onFrame(bitmap: Bitmap) {
                     latestBitmap = bitmap
+                    if (frameCount == 0) {
+                        Log.i(FLOW_TAG, "[FlirManager] FIRST FRAME received: ${bitmap.width}x${bitmap.height}")
+                    }
+                    frameCount++
                     textureCallback?.onTextureUpdate(bitmap, 0)
                     emitFrameToReactNative(bitmap)
                 }
@@ -90,64 +136,164 @@ object FlirManager {
                     temperatureCallback?.onTemperatureData(temp, x, y)
                 }
 
-                override fun onDeviceFound(name: String) {
-                    connectedDeviceName = name
-                    isPhysicalDeviceConnected = true
-                    emitDeviceState("connected", true)
+                override fun onDeviceFound(deviceId: String, deviceName: String, isEmulator: Boolean) {
+                    Log.i(FLOW_TAG, "[FlirManager] Device found: $deviceName (id=$deviceId, emulator=$isEmulator)")
+                    Log.d(TAG, "Device found: $deviceName (id=$deviceId, emulator=$isEmulator)")
+                    discoveryCallback?.onDeviceFound(deviceName)
                 }
-
-                override fun onEmulatorEnabled() {
-                    isEmulatorMode = true
-                    emitDeviceState("emulator", false)
+                
+                override fun onDeviceListUpdated(devices: MutableList<FlirSdkManager.DeviceInfo>) {
+                    discoveredDevices = devices.toList()
+                    Log.i(FLOW_TAG, "[FlirManager] Device list updated: ${devices.size} devices")
+                    Log.i(TAG, "Device list updated: ${devices.size} devices")
+                    devices.forEach { 
+                        Log.d(TAG, "  - ${it.deviceName} (${it.commInterface}, emu=${it.isEmulator})")
+                    }
+                    emitDevicesFound(devices)
+                    
+                    // Auto-connect to first device if available
+                    if (devices.isNotEmpty()) {
+                        val first = devices[0]
+                        connectedDeviceName = first.deviceName
+                        connectedDeviceId = first.deviceId
+                        isEmulatorMode = first.isEmulator
+                        isPhysicalDeviceConnected = !first.isEmulator
+                        
+                        Log.i(FLOW_TAG, "[FlirManager] Auto-connecting to first device: ${first.deviceName}")
+                        // Connect to the device
+                        sdkManager?.connectToDevice(first.deviceId)
+                    }
                 }
-
-                override fun onStreamKindChanged(kind: String) {
-                    Log.d(TAG, "Stream kind changed: $kind")
+                
+                override fun onDeviceConnected(deviceId: String, deviceName: String, isEmulator: Boolean) {
+                    connectedDeviceId = deviceId
+                    connectedDeviceName = deviceName
+                    this@FlirManager.isEmulatorMode = isEmulator
+                    isPhysicalDeviceConnected = !isEmulator
+                    
+                    Log.i(TAG, "Device connected: $deviceName (id=$deviceId, emulator=$isEmulator)")
+                    emitDeviceState("connected", !isEmulator)
+                }
+                
+                override fun onDeviceDisconnected() {
+                    Log.i(TAG, "Device disconnected")
+                    isPhysicalDeviceConnected = false
+                    isEmulatorMode = false
+                    isStreaming = false
+                    connectedDeviceId = null
+                    connectedDeviceName = null
+                    emitDeviceState("disconnected", false)
+                }
+                
+                override fun onDiscoveryStarted() {
+                    Log.i(TAG, "Discovery started")
+                    emitDeviceState("discovering", false)
+                }
+                
+                override fun onDiscoveryTimeout() {
+                    Log.w(TAG, "Discovery timeout - no devices found")
+                    discoveryCallback?.onDiscoveryTimeout()
+                    emitDeviceState("discovery_timeout", false)
+                }
+                
+                override fun onStreamStarted(streamType: String) {
+                    isStreaming = true
+                    Log.i(TAG, "Streaming started: $streamType")
+                    emitDeviceState("streaming", isPhysicalDeviceConnected)
                 }
-            })
+                
+                override fun onError(error: String) {
+                    Log.e(TAG, "SDK Error: $error")
+                    emitError(error)
+                }
+            }, context)
             
-            // 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}")
-            }
+            // Set emulator type preference
+            sdkManager?.setEmulatorType(preferredEmulatorType)
+            
+            Log.i(TAG, "FlirManager initialized with comprehensive SDK manager")
         } catch (t: Throwable) {
             Log.e(TAG, "FlirManager init failed", t)
         }
     }
 
-    fun startDiscoveryAndConnect(context: ThemedReactContext) {
-        if (discoveryStarted) return
+    /**
+     * Start discovery with the specified parameters
+     * @param isEmuMode If true, immediately start emulator without physical device discovery
+     */
+    fun startDiscoveryAndConnect(context: ThemedReactContext, isEmuMode: Boolean = false) {
+        Log.i(FLOW_TAG, "[FlirManager] startDiscoveryAndConnect called: isEmuMode=$isEmuMode, discoveryStarted=$discoveryStarted, preferredEmulatorType=$preferredEmulatorType")
+        
+        if (discoveryStarted && !isEmuMode) {
+            Log.i(FLOW_TAG, "[FlirManager] Discovery already started, skipping")
+            return
+        }
         discoveryStarted = true
         reactContext = context
+        frameCount = 0  // Reset frame counter
 
         emitDeviceState("discovering", false)
 
         try {
-            val started = sdkManager?.startSdkEmulator() ?: false
-            if (!started) {
-                Log.w(TAG, "Failed to start SDK emulator")
-                emitDeviceState("error", false)
-            }
+            // Set emulator type preference before discovery
+            Log.i(FLOW_TAG, "[FlirManager] Setting emulator type: $preferredEmulatorType")
+            sdkManager?.setEmulatorType(preferredEmulatorType)
+            
+            // Start discovery (forceEmulator=isEmuMode)
+            Log.i(FLOW_TAG, "[FlirManager] Calling sdkManager.startDiscovery(forceEmulator=$isEmuMode)")
+            Log.i(TAG, "Starting discovery (forceEmulator=$isEmuMode)")
+            sdkManager?.startDiscovery(isEmuMode)
         } catch (t: Throwable) {
+            Log.e(FLOW_TAG, "[FlirManager] startDiscoveryAndConnect failed: ${t.message}")
             Log.e(TAG, "startDiscoveryAndConnect failed", t)
             emitDeviceState("error", false)
         }
     }
+    
+    /**
+     * Legacy overload for backward compatibility
+     */
+    fun startDiscoveryAndConnect(context: ThemedReactContext) {
+        startDiscoveryAndConnect(context, isEmuMode = false)
+    }
+
+    /**
+     * Switch to a specific device by ID
+     */
+    fun switchToDevice(deviceId: String) {
+        if (deviceId == connectedDeviceId) {
+            Log.d(TAG, "Already connected to device: $deviceId")
+            return
+        }
+        
+        Log.i(TAG, "Switching to device: $deviceId")
+        sdkManager?.connectToDevice(deviceId)
+    }
+    
+    /**
+     * Start emulator mode
+     */
+    fun startEmulator(type: FlirSdkManager.EmulatorType = preferredEmulatorType) {
+        Log.i(TAG, "Starting emulator: $type")
+        sdkManager?.setEmulatorType(type)
+        sdkManager?.startDiscovery(true) // forceEmulator = true
+    }
 
     fun stop() {
+        Log.i(TAG, "Stopping FlirManager")
+        
+        // Stop the SDK manager
+        sdkManager?.stop()
+        
+        // Reset state
         discoveryStarted = false
         isPhysicalDeviceConnected = false
         isEmulatorMode = false
+        isStreaming = false
         connectedDeviceName = null
+        connectedDeviceId = null
         latestBitmap = null
-        // Note: FlirSdkManager doesn't have a stop method, but we reset our state
+        discoveredDevices = emptyList()
     }
 
     fun getLatestFramePath(): String? {
@@ -193,15 +339,59 @@ object FlirManager {
             params.putString("state", state)
             params.putBoolean("isPhysical", isPhysical)
             params.putBoolean("isEmulator", isEmulatorMode)
-            params.putBoolean("isConnected", isPhysicalDeviceConnected)
+            params.putBoolean("isConnected", isPhysicalDeviceConnected || isEmulatorMode)
+            params.putBoolean("isStreaming", isStreaming)
             
             connectedDeviceName?.let {
                 params.putString("deviceName", it)
             }
+            connectedDeviceId?.let {
+                params.putString("deviceId", it)
+            }
 
             ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 .emit("FlirDeviceConnected", params)
-        } catch (e: Exception) {}
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to emit device state", e)
+        }
+    }
+    
+    private fun emitDevicesFound(devices: List<FlirSdkManager.DeviceInfo>) {
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap()
+            val devicesArray: WritableArray = Arguments.createArray()
+            
+            devices.forEach { device ->
+                val deviceMap: WritableMap = Arguments.createMap()
+                deviceMap.putString("id", device.deviceId)
+                deviceMap.putString("name", device.deviceName)
+                deviceMap.putString("communicationType", device.commInterface.name)
+                deviceMap.putBoolean("isEmulator", device.isEmulator)
+                devicesArray.pushMap(deviceMap)
+            }
+            
+            params.putArray("devices", devicesArray)
+            params.putInt("count", devices.size)
+
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirDevicesFound", params)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to emit devices found", e)
+        }
+    }
+    
+    private fun emitError(message: String) {
+        val ctx = reactContext ?: return
+        try {
+            val params = Arguments.createMap()
+            params.putString("error", message)
+
+            ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("FlirError", params)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to emit error", e)
+        }
     }
 
     // Compatibility for Java / FlirHelper
@@ -225,9 +415,10 @@ object FlirManager {
     }
 
     fun setEmulatorMode(enabled: Boolean) {
-        isEmulatorMode = enabled
         if (enabled) {
-             discoveryCallback?.onEmulatorEnabled()
+            isEmulatorMode = true
+            discoveryCallback?.onEmulatorEnabled()
+            startEmulator(preferredEmulatorType)
         }
     }
 
@@ -236,19 +427,51 @@ object FlirManager {
     }
 
     fun startDiscovery(retry: Boolean) {
-        if (reactContext != null) {
-            startDiscoveryAndConnect(reactContext!!)
-        } else {
-            // Fallback: try to start without React context
+        Log.i(FLOW_TAG, "[FlirManager] startDiscovery($retry) called, sdkManager=${if (sdkManager != null) "present" else "NULL"}, appContext=${if (appContext != null) "present" else "NULL"}")
+        
+        // Auto-init if not initialized
+        if (sdkManager == null && appContext != null) {
+            Log.i(FLOW_TAG, "[FlirManager] Auto-initializing from startDiscovery()")
+            init(appContext!!)
+        }
+        
+        val ctx = reactContext
+        if (ctx != null) {
+            // Reset discovery state if retrying
+            if (retry) {
+                discoveryStarted = false
+            }
+            startDiscoveryAndConnect(ctx, isEmuMode = false)
+        } else if (appContext != null) {
+            // Fallback: try to start discovery without React context
             try {
-                sdkManager?.startSdkEmulator()
+                Log.w(TAG, "Starting discovery without React context")
+                Log.i(FLOW_TAG, "[FlirManager] Calling sdkManager.startDiscovery(false) without React context")
+                sdkManager?.startDiscovery(false)
             } catch (t: Throwable) {
                 Log.e(TAG, "startDiscovery failed", t)
+                Log.e(FLOW_TAG, "[FlirManager] startDiscovery failed: ${t.message}")
             }
+        } else {
+            Log.e(FLOW_TAG, "[FlirManager] Cannot startDiscovery - no context available! Call init(context) first.")
         }
     }
     
     fun enableEmulatorMode() {
         setEmulatorMode(true)
     }
+    
+    /**
+     * Force start with emulator (useful for testing)
+     */
+    fun forceEmulatorMode(type: String = "FLIR_ONE_EDGE") {
+        setPreferredEmulatorType(type)
+        val ctx = reactContext
+        if (ctx != null) {
+            discoveryStarted = false
+            startDiscoveryAndConnect(ctx, isEmuMode = true)
+        } else {
+            startEmulator(preferredEmulatorType)
+        }
+    }
 }

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

@@ -71,4 +71,36 @@ class FlirModule(private val reactContext: ReactApplicationContext) : ReactConte
             promise.reject("ERR_FLIR_DEVICE_INFO", e)
         }
     }
+    
+    @ReactMethod
+    fun isSDKDownloaded(promise: Promise) {
+        try {
+            val available = FlirSDKLoader.isSDKAvailable(reactContext)
+            promise.resolve(available)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_SDK_CHECK", e)
+        }
+    }
+    
+    @ReactMethod
+    fun getSDKStatus(promise: Promise) {
+        try {
+            val available = FlirSDKLoader.isSDKAvailable(reactContext)
+            val arch = FlirSDKLoader.getDeviceArch()
+            val dexPath = FlirSDKLoader.getDexPath(reactContext)
+            val nativeLibDir = FlirSDKLoader.getNativeLibDir(reactContext)
+            
+            val result = com.facebook.react.bridge.Arguments.createMap()
+            result.putBoolean("available", available)
+            result.putString("arch", arch)
+            result.putString("dexPath", dexPath?.absolutePath ?: "not downloaded")
+            result.putString("nativeLibPath", nativeLibDir?.absolutePath ?: "not downloaded")
+            result.putBoolean("dexExists", dexPath?.exists() == true)
+            result.putBoolean("nativeLibsExist", nativeLibDir?.exists() == true)
+            
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_SDK_STATUS", e)
+        }
+    }
 }