ilabs-flir 1.0.0

package/android/Flir/build.gradle.kts

@@ -0,0 +1,80 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+    id("maven-publish")
+}
+
+android {
+    namespace = "flir.android"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 24
+        targetSdk = 34
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    publishing {
+        singleVariant("release") {
+            withJavadocJar()
+            withSourcesJar()
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    // Resolve local AARs which will be installed into mavenLocal by CI (JitPack)
+    mavenLocal()
+    flatDir { dirs("libs") }
+}
+
+dependencies {
+    // React Native
+    implementation("com.facebook.react:react-native:+")
+    
+    // Kotlin coroutines for async downloads
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
+    
+    // Play Feature Delivery (optional - for Play Store SDK delivery)
+    implementation("com.google.android.play:feature-delivery:2.1.0")
+    implementation("com.google.android.play:feature-delivery-ktx:2.1.0")
+    
+    // FLIR SDK binary artifacts - compileOnly since they're downloaded on-demand at runtime
+    // These are needed for compilation but NOT bundled with the app
+    // Users download them at runtime via FlirDownload.download()
+    compileOnly(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar", "*.jar"))))
+    
+    // Minimal compile deps to satisfy source references
+    implementation("androidx.annotation:annotation:1.5.0")
+
+
+    // Prevent duplicate SLF4J classes when a consumer also brings `org.slf4j:slf4j-api`
+    // The vendor AAR may embed slf4j classes; exclude the API from being pulled transitively
+    configurations.all {
+        exclude(group = "org.slf4j", module = "slf4j-api")
+    }
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("release") {
+            afterEvaluate {
+                from(components["release"])
+                groupId = "com.github.PraveenOjha"
+                artifactId = "Flir"
+                version = project.version.toString().ifEmpty { "unspecified" }
+            }
+        }
+    }
+}

package/android/Flir/src/main/AndroidManifest.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- ============================================ -->
+    <!-- FLIR Thermal SDK Required Permissions       -->
+    <!-- These will auto-merge into your app         -->
+    <!-- ============================================ -->
+
+    <!-- USB Host feature for FLIR ONE USB devices -->
+    <!-- This is the primary interface for FLIR ONE cameras -->
+    <uses-feature
+        android:name="android.hardware.usb.host"
+        android:required="false" />
+
+    <!-- Camera support for network-based FLIR cameras (ACE series) -->
+    <!-- Set to false so app can still install on devices without cameras -->
+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+
+    <!-- Camera permission for ACE cameras that use device camera -->
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <!-- Internet permission for ACE camera internal communication -->
+    <!-- Required by ACE SDK architecture for local network communication -->
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <!-- Note: USB permissions are handled at runtime via UsbPermissionHandler -->
+    <!-- No additional USB permissions needed in manifest -->
+
+</manifest>

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

@@ -0,0 +1,194 @@
+package flir.android;
+
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import com.flir.thermalsdk.androidsdk.image.BitmapAndroid;
+import com.flir.thermalsdk.image.ThermalImage;
+import com.flir.thermalsdk.live.Camera;
+import com.flir.thermalsdk.live.CommunicationInterface;
+import com.flir.thermalsdk.live.ConnectParameters;
+import com.flir.thermalsdk.live.Identity;
+import com.flir.thermalsdk.live.connectivity.ConnectionStatusListener;
+import com.flir.thermalsdk.live.discovery.DiscoveryEventListener;
+import com.flir.thermalsdk.live.discovery.DiscoveryFactory;
+import com.flir.thermalsdk.live.streaming.Stream;
+import com.flir.thermalsdk.live.streaming.ThermalStreamer;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.Objects;
+
+public class CameraHandler {
+    
+    private static final String TAG = "CameraHandler";
+
+    private StreamDataListener streamDataListener;
+
+    public interface StreamDataListener {
+        void images(FrameDataHolder dataHolder);
+        void images(Bitmap msxBitmap, Bitmap dcBitmap);
+    }
+
+    LinkedList<Identity> foundCameraIdentities = new LinkedList<>();
+
+    private Camera camera;
+
+    private Stream connectedStream;
+    private ThermalStreamer streamer;
+    // Cache the latest ThermalImage delivered by the streamer
+    private ThermalImage latestThermalImage;
+
+    public CameraHandler() {
+        Log.d(TAG, "CameraHandler constr");
+    }
+
+    public void startDiscovery(DiscoveryEventListener cameraDiscoveryListener, DiscoveryStatus discoveryStatus) {
+        DiscoveryFactory.getInstance().scan(cameraDiscoveryListener, CommunicationInterface.EMULATOR, CommunicationInterface.USB);
+        discoveryStatus.started();
+    }
+
+    public void stopDiscovery(DiscoveryStatus discoveryStatus) {
+        DiscoveryFactory.getInstance().stop(CommunicationInterface.EMULATOR, CommunicationInterface.USB);
+        discoveryStatus.stopped();
+    }
+
+    public synchronized void connect(Identity identity, ConnectionStatusListener connectionStatusListener) throws IOException {
+        Log.d(TAG, "connect identity: " + identity);
+        camera = new Camera();
+        camera.connect(identity, connectionStatusListener, new ConnectParameters());
+    }
+
+    public synchronized void disconnect() {
+        Log.d(TAG, "disconnect");
+        if (camera == null) {
+            return;
+        }
+        if (connectedStream == null) {
+            return;
+        }
+
+        if (connectedStream.isStreaming()) {
+            connectedStream.stop();
+        }
+        camera.disconnect();
+        camera = null;
+    }
+
+    public synchronized void startStream(StreamDataListener listener) {
+        this.streamDataListener = listener;
+        if (camera == null || !camera.isConnected()) {
+            Log.e(TAG, "startStream, failed, camera was null or not connected");
+            return;
+        }
+        connectedStream = camera.getStreams().get(0);
+        if (connectedStream.isThermal()) {
+            streamer = new ThermalStreamer(connectedStream);
+        } else {
+            Log.e(TAG, "startStream, failed, no thermal stream available for the camera");
+            return;
+        }
+        connectedStream.start(
+                unused -> {
+                    streamer.update();
+                    final Bitmap[] dcBitmap = new Bitmap[1];
+                    streamer.withThermalImage(thermalImage -> {
+                        try {
+                            // Cache the latest ThermalImage for sampling
+                            latestThermalImage = thermalImage;
+                            if (thermalImage.getFusion() != null && thermalImage.getFusion().getPhoto() != null) {
+                                dcBitmap[0] = BitmapAndroid.createBitmap(thermalImage.getFusion().getPhoto()).getBitMap();
+                            }
+                            // The streamer.getImage() returns the ImageBuffer expected by BitmapAndroid
+                            final Bitmap thermalPixels = BitmapAndroid.createBitmap(streamer.getImage()).getBitMap();
+                            if (streamDataListener != null) streamDataListener.images(thermalPixels, dcBitmap[0]);
+                        } catch (Exception e) {
+                            Log.e(TAG, "thermal bitmap creation error", e);
+                        }
+                    });
+                },
+                error -> Log.e(TAG, "Streaming error: " + error));
+    }
+
+    public synchronized Double getTemperatureAt(int x, int y) {
+        try {
+            if (streamer == null) return null;
+            ThermalImage img = latestThermalImage;
+            if (img == null) return null;
+
+            java.lang.reflect.Method[] methods = img.getClass().getMethods();
+            for (java.lang.reflect.Method m : methods) {
+                String name = m.getName().toLowerCase();
+                Class<?>[] params = m.getParameterTypes();
+
+                if ((name.contains("get") || name.contains("value") || name.contains("temperature")) && params.length == 2
+                        && (params[0] == int.class || params[0] == Integer.class || params[0] == double.class || params[0] == float.class)
+                        && (params[1] == int.class || params[1] == Integer.class || params[1] == double.class || params[1] == float.class)) {
+                    try {
+                        Object res = null;
+                        if (params[0] == int.class && params[1] == int.class) {
+                            res = m.invoke(img, x, y);
+                        } else if (params[0] == double.class && params[1] == double.class) {
+                            res = m.invoke(img, (double) x, (double) y);
+                        } else if (params[0] == float.class && params[1] == float.class) {
+                            res = m.invoke(img, (float) x, (float) y);
+                        } else {
+                            res = m.invoke(img, Integer.valueOf(x), Integer.valueOf(y));
+                        }
+                        if (res instanceof Number) {
+                            return ((Number) res).doubleValue();
+                        }
+                    } catch (Exception e) {
+                    }
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "getTemperatureAt error", e);
+        }
+        return null;
+    }
+
+    public void add(Identity identity) {
+        foundCameraIdentities.add(identity);
+    }
+
+    public Identity getCppEmulator() {
+        for (Identity foundCameraIdentity : foundCameraIdentities) {
+            if (foundCameraIdentity.deviceId.contains("C++ Emulator")) {
+                return foundCameraIdentity;
+            }
+        }
+        return null;
+    }
+
+    public Identity getFlirOneEmulator() {
+        for (Identity foundCameraIdentity : foundCameraIdentities) {
+            if (foundCameraIdentity.deviceId.contains("EMULATED FLIR ONE")) {
+                return foundCameraIdentity;
+            }
+        }
+        return null;
+    }
+
+    public Identity getFlirOne() {
+        for (Identity foundCameraIdentity : foundCameraIdentities) {
+            if (foundCameraIdentity.communicationInterface == CommunicationInterface.USB) return foundCameraIdentity;
+        }
+        return null;
+    }
+
+    public String getDeviceInfo() {
+        if (camera == null) return "N/A";
+        try {
+            if (camera.getRemoteControl() == null) return "N/A";
+            return camera.getRemoteControl().cameraInformation().getSync().displayName;
+        } catch (Exception e) {
+            return "N/A";
+        }
+    }
+
+    public interface DiscoveryStatus {
+        void started();
+        void stopped();
+    }
+}

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

@@ -0,0 +1,11 @@
+package flir.android
+
+object FlirController {
+    @JvmStatic
+    var cameraHandler: CameraHandler? = null
+
+    @JvmStatic
+    fun getTemperatureAt(x: Int, y: Int): Double? {
+        return cameraHandler?.getTemperatureAt(x, y)
+    }
+}

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

@@ -0,0 +1,75 @@
+package flir.android
+
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.coroutines.*
+
+class FlirDownloadManager(private val reactContext: ReactApplicationContext) : 
+    ReactContextBaseJavaModule(reactContext) {
+    
+    private var downloadJob: Job? = null
+    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+    
+    override fun getName() = "FlirDownloadManager"
+    
+    override fun initialize() {
+        FlirSDKLoader.init(reactContext)
+    }
+    
+    @ReactMethod
+    fun isFlirAvailable(promise: Promise) {
+        promise.resolve(FlirSDKLoader.isSDKAvailable(reactContext))
+    }
+    
+    @ReactMethod
+    fun getDownloadSize(promise: Promise) {
+        promise.resolve(FlirSDKLoader.getDownloadSize(reactContext).toDouble())
+    }
+    
+    @ReactMethod
+    fun downloadFlirSDK(promise: Promise) {
+        downloadJob = scope.launch {
+            val result = FlirSDKLoader.downloadDirect(reactContext) { downloaded, total ->
+                sendEvent("FlirDownloadProgress", Arguments.createMap().apply {
+                    putDouble("bytesDownloaded", downloaded.toDouble())
+                    putDouble("totalBytes", total.toDouble())
+                    putDouble("percent", (downloaded.toDouble() / total) * 100)
+                })
+            }
+            
+            result.fold(
+                onSuccess = {
+                    sendEvent("FlirDownloadComplete", Arguments.createMap())
+                    promise.resolve(true)
+                },
+                onFailure = { error ->
+                    sendEvent("FlirDownloadError", Arguments.createMap().apply {
+                        putString("error", error.message)
+                    })
+                    promise.reject("E_DOWNLOAD", error.message, error)
+                }
+            )
+        }
+    }
+    
+    @ReactMethod
+    fun cancelDownload() {
+        downloadJob?.cancel()
+    }
+    
+    @ReactMethod
+    fun deleteSDK(promise: Promise) {
+        promise.resolve(FlirSDKLoader.deleteSDK(reactContext))
+    }
+    
+    @ReactMethod
+    fun addListener(eventName: String) {}
+    
+    @ReactMethod
+    fun removeListeners(count: Int) {}
+    
+    private fun sendEvent(name: String, params: WritableMap) {
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(name, params)
+    }
+}

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

@@ -0,0 +1,16 @@
+package flir.android
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class FlirDownloadPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(FlirDownloadManager(reactContext))
+    }
+    
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,6 @@
+package flir.android
+
+object FlirFrameCache {
+    @JvmStatic
+    var latestFramePath: String? = null
+}

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

@@ -0,0 +1,248 @@
+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) {}
+    }
+}