ilabs-flir 1.0.0

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

@@ -0,0 +1,74 @@
+package flir.android
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+class FlirModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String = "FlirModule"
+
+    // Simple placeholder conversion: converts an ARGB color to a pseudo-temperature value.
+    // Replace with SDK call when integrating thermalsdk APIs.
+    @ReactMethod
+    fun getTemperatureFromColor(color: Int, promise: Promise) {
+        try {
+            val r = (color shr 16) and 0xFF
+            val g = (color shr 8) and 0xFF
+            val b = color and 0xFF
+            // Luminance-like value scaled to a plausible temperature range (0°C - 400°C)
+            val lum = 0.2126 * r + 0.7152 * g + 0.0722 * b
+            val temp = 0.0 + (lum / 255.0) * 400.0
+            promise.resolve(temp)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_CONVERT", e)
+        }
+    }
+
+    @ReactMethod
+    fun getLatestFramePath(promise: Promise) {
+        try {
+            val path = FlirFrameCache.latestFramePath
+            if (path != null) promise.resolve(path) else promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_PATH", e)
+        }
+    }
+
+    @ReactMethod
+    fun getTemperatureAt(x: Int, y: Int, promise: Promise) {
+        try {
+            val temp = FlirManager.getTemperatureAt(x, y)
+            if (temp != null) promise.resolve(temp) else promise.reject("ERR_NO_DATA", "No temperature data available")
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_SAMPLE", e)
+        }
+    }
+    
+    @ReactMethod
+    fun isEmulator(promise: Promise) {
+        try {
+            promise.resolve(FlirManager.isEmulator())
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_EMULATOR_CHECK", e)
+        }
+    }
+    
+    @ReactMethod
+    fun isDeviceConnected(promise: Promise) {
+        try {
+            promise.resolve(FlirManager.isDeviceConnected())
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_DEVICE_CHECK", e)
+        }
+    }
+    
+    @ReactMethod
+    fun getConnectedDeviceInfo(promise: Promise) {
+        try {
+            promise.resolve(FlirManager.getConnectedDeviceInfo())
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_DEVICE_INFO", e)
+        }
+    }
+}

package/android/Flir/src/main/java/flir/android/FlirPackage.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 FlirPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(FlirModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(FlirViewManager())
+    }
+}

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

@@ -0,0 +1,191 @@
+package flir.android
+
+import android.content.Context
+import com.google.android.play.core.splitinstall.*
+import com.google.android.play.core.splitinstall.model.SplitInstallSessionStatus
+import kotlinx.coroutines.*
+import org.json.JSONObject
+import java.io.File
+import java.io.FileOutputStream
+import java.net.URL
+import java.security.MessageDigest
+import java.util.zip.ZipInputStream
+
+object FlirSDKLoader {
+    
+    private const val FEATURE_MODULE = "flir_sdk"
+    private var splitInstallManager: SplitInstallManager? = null
+    
+    fun init(context: Context) {
+        splitInstallManager = SplitInstallManagerFactory.create(context)
+    }
+    
+    private fun getSDKDirectory(context: Context) = File(context.filesDir, "FlirSDK")
+    
+    fun isSDKAvailable(context: Context): Boolean {
+        // Check Play Feature module
+        splitInstallManager?.installedModules?.let {
+            if (FEATURE_MODULE in it) return true
+        }
+        // Check direct download
+        return File(getSDKDirectory(context), "thermalsdk.aar").exists()
+    }
+    
+    fun getDownloadSize(context: Context): Long {
+        return loadManifest(context)?.android?.directDownload?.sizeBytes ?: 52_428_800L
+    }
+    
+    fun downloadViaPlayStore(
+        onProgress: (Float) -> Unit,
+        onComplete: () -> Unit,
+        onError: (String) -> Unit
+    ) {
+        val manager = splitInstallManager ?: run {
+            onError("SplitInstallManager not initialized")
+            return
+        }
+        
+        val request = SplitInstallRequest.newBuilder()
+            .addModule(FEATURE_MODULE)
+            .build()
+        
+        manager.registerListener { state ->
+            when (state.status()) {
+                SplitInstallSessionStatus.DOWNLOADING -> {
+                    val progress = state.bytesDownloaded().toFloat() / state.totalBytesToDownload()
+                    onProgress(progress)
+                }
+                SplitInstallSessionStatus.INSTALLED -> onComplete()
+                SplitInstallSessionStatus.FAILED -> onError("Install failed: ${state.errorCode()}")
+                else -> {}
+            }
+        }
+        
+        manager.startInstall(request)
+    }
+    
+    suspend fun downloadDirect(
+        context: Context,
+        onProgress: (downloaded: Long, total: Long) -> Unit
+    ): Result<Unit> = withContext(Dispatchers.IO) {
+        try {
+            val manifest = loadManifest(context) ?: return@withContext Result.failure(
+                Exception("Failed to load manifest"))
+            
+            val downloadUrl = manifest.android.directDownload.downloadUrl
+            val expectedHash = manifest.android.directDownload.sha256
+            val totalSize = manifest.android.directDownload.sizeBytes
+            
+            val sdkDir = getSDKDirectory(context).apply { mkdirs() }
+            val zipFile = File(context.cacheDir, "flir-sdk.zip")
+            
+            // Download
+            URL(downloadUrl).openStream().use { input ->
+                FileOutputStream(zipFile).use { output ->
+                    val buffer = ByteArray(8192)
+                    var totalRead = 0L
+                    var bytesRead: Int
+                    
+                    while (input.read(buffer).also { bytesRead = it } != -1) {
+                        output.write(buffer, 0, bytesRead)
+                        totalRead += bytesRead
+                        withContext(Dispatchers.Main) {
+                            onProgress(totalRead, totalSize)
+                        }
+                    }
+                }
+            }
+            
+            // Verify checksum
+            val actualHash = sha256(zipFile)
+            if (actualHash != expectedHash) {
+                zipFile.delete()
+                return@withContext Result.failure(SecurityException("Checksum mismatch"))
+            }
+            
+            // Extract
+            unzip(zipFile, sdkDir)
+            zipFile.delete()
+            
+            Result.success(Unit)
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+    
+    fun deleteSDK(context: Context): Boolean {
+        splitInstallManager?.deferredUninstall(listOf(FEATURE_MODULE))
+        return getSDKDirectory(context).deleteRecursively()
+    }
+    
+    private fun loadManifest(context: Context): SDKManifest? {
+        return try {
+            val json = context.assets.open("sdk-manifest.json").bufferedReader().readText()
+            SDKManifest.fromJson(json)
+        } catch (e: Exception) { null }
+    }
+    
+    private fun sha256(file: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buffer = ByteArray(8192)
+            var bytesRead: Int
+            while (input.read(buffer).also { bytesRead = it } != -1) {
+                digest.update(buffer, 0, bytesRead)
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+    
+    private fun unzip(source: File, destination: File) {
+        ZipInputStream(source.inputStream()).use { zip ->
+            var entry = zip.nextEntry
+            while (entry != null) {
+                val file = File(destination, entry.name)
+                if (entry.isDirectory) {
+                    file.mkdirs()
+                } else {
+                    file.parentFile?.mkdirs()
+                    file.outputStream().use { zip.copyTo(it) }
+                }
+                entry = zip.nextEntry
+            }
+        }
+    }
+}
+
+data class SDKManifest(
+    val version: String,
+    val android: AndroidManifest
+) {
+    data class AndroidManifest(
+        val playFeatureModule: String,
+        val directDownload: DirectDownload
+    )
+    
+    data class DirectDownload(
+        val downloadUrl: String,
+        val sha256: String,
+        val sizeBytes: Long
+    )
+    
+    companion object {
+        fun fromJson(json: String): SDKManifest {
+            val root = JSONObject(json)
+            val android = root.getJSONObject("android")
+            val direct = android.getJSONObject("directDownload")
+            
+            return SDKManifest(
+                version = root.getString("version"),
+                android = AndroidManifest(
+                    playFeatureModule = android.getString("playFeatureModule"),
+                    directDownload = DirectDownload(
+                        downloadUrl = direct.getString("downloadUrl"),
+                        sha256 = direct.getString("sha256"),
+                        sizeBytes = direct.getLong("sizeBytes")
+                    )
+                )
+            )
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+package flir.android
+
+object FlirStatus {
+    @JvmStatic
+    var flirConnected: Boolean = false
+
+    @JvmStatic
+    var flirStreaming: Boolean = false
+
+    @JvmStatic
+    var latestFramePath: String? = null
+}

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

@@ -0,0 +1,48 @@
+package flir.android
+
+import android.content.Context
+import android.graphics.Color
+import android.view.TextureView
+import android.widget.FrameLayout
+import android.widget.TextView
+import com.facebook.react.uimanager.ThemedReactContext
+
+class FlirView(context: ThemedReactContext) : FrameLayout(context) {
+    private val textureView: TextureView
+
+    init {
+        textureView = TextureView(context)
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        addView(textureView)
+
+        // Simple placeholder overlay to indicate native FLIR view
+        val overlay = TextView(context)
+        overlay.text = "FLIR Preview"
+        overlay.setTextColor(Color.WHITE)
+        overlay.setPadding(12, 12, 12, 12)
+        addView(overlay)
+
+        // Ensure SDK is initialized
+        FlirManager.init(context)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        // Let the centralized manager handle discovery and streaming and emit events
+        try {
+            FlirManager.startDiscoveryAndConnect(context as ThemedReactContext)
+        } catch (ignored: Throwable) {}
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        try {
+            FlirManager.stop()
+        } catch (ignored: Throwable) {}
+    }
+
+    // Called by JS/native module to get latest frame cache file
+    fun getLatestFramePath(): String? {
+        return FlirManager.getLatestFramePath()
+    }
+}

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

@@ -0,0 +1,13 @@
+package flir.android
+
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import android.view.View
+
+class FlirViewManager : SimpleViewManager<View>() {
+    override fun getName(): String = "FLIRCameraView"
+
+    override fun createViewInstance(reactContext: ThemedReactContext): View {
+        return FlirView(reactContext)
+    }
+}

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

@@ -0,0 +1,14 @@
+package flir.android;
+
+import android.graphics.Bitmap;
+
+public class FrameDataHolder {
+    
+    public final Bitmap msxBitmap;
+    public final Bitmap dcBitmap;
+
+    public FrameDataHolder(Bitmap msxBitmap, Bitmap dcBitmap) {
+        this.msxBitmap = msxBitmap;
+        this.dcBitmap = dcBitmap;
+    }
+}

package/app.plugin.js

@@ -0,0 +1,264 @@
+const {
+  withInfoPlist,
+  withAndroidManifest,
+  withDangerousMod,
+  createRunOncePlugin,
+} = require('@expo/config-plugins');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * FLIR Thermal SDK Config Plugin
+ * 
+ * Automatically adds required iOS Info.plist and Android AndroidManifest.xml 
+ * entries for FLIR device support. This eliminates the need for manual editing.
+ * 
+ * Usage in app.json:
+ * {
+ *   "plugins": ["ilabs-flir"]
+ * }
+ * 
+ * Or with custom descriptions:
+ * {
+ *   "plugins": [
+ *     ["ilabs-flir", {
+ *       "bluetoothAlwaysUsageDescription": "Custom description here",
+ *       "bluetoothPeripheralUsageDescription": "Custom description here"
+ *     }]
+ *   ]
+ * }
+ */
+
+const EXTERNAL_ACCESSORY_PROTOCOLS = [
+  'com.flir.rosebud.config',
+  'com.flir.rosebud.frame',
+  'com.flir.rosebud.fileio',
+];
+
+const DEFAULT_BLUETOOTH_ALWAYS_DESCRIPTION =
+  'This app requires Bluetooth to connect to FLIR thermal cameras via Bluetooth Low Energy';
+
+const DEFAULT_BLUETOOTH_PERIPHERAL_DESCRIPTION =
+  'This app uses Bluetooth to communicate with FLIR thermal imaging devices';
+
+/**
+ * Adds FLIR-specific Info.plist entries for iOS
+ */
+const withFlirInfoPlist = (config, props = {}) => {
+  return withInfoPlist(config, (config) => {
+    const infoPlist = config.modResults;
+
+    // Add External Accessory Protocols for FLIR ONE devices
+    // These protocols enable Lightning interface communication (FLIR ONE Classic)
+    // and prepare for Bluetooth LE devices (FLIR ONE Edge/Pro)
+    if (!infoPlist.UISupportedExternalAccessoryProtocols) {
+      infoPlist.UISupportedExternalAccessoryProtocols = [];
+    }
+
+    // Merge protocols without duplicates
+    const existingProtocols = infoPlist.UISupportedExternalAccessoryProtocols;
+    EXTERNAL_ACCESSORY_PROTOCOLS.forEach((protocol) => {
+      if (!existingProtocols.includes(protocol)) {
+        existingProtocols.push(protocol);
+      }
+    });
+
+    // Add Bluetooth permissions for FLIR ONE Edge/Pro (BLE devices)
+    // iOS 13+ requires NSBluetoothAlwaysUsageDescription
+    if (!infoPlist.NSBluetoothAlwaysUsageDescription) {
+      infoPlist.NSBluetoothAlwaysUsageDescription =
+        props.bluetoothAlwaysUsageDescription ||
+        DEFAULT_BLUETOOTH_ALWAYS_DESCRIPTION;
+    }
+
+    // Older iOS versions (pre-13) require NSBluetoothPeripheralUsageDescription
+    if (!infoPlist.NSBluetoothPeripheralUsageDescription) {
+      infoPlist.NSBluetoothPeripheralUsageDescription =
+        props.bluetoothPeripheralUsageDescription ||
+        DEFAULT_BLUETOOTH_PERIPHERAL_DESCRIPTION;
+    }
+
+    return config;
+  });
+};
+
+/**
+ * Adds FLIR-specific AndroidManifest.xml entries for Android
+ */
+const withFlirAndroidManifest = (config) => {
+  return withAndroidManifest(config, (config) => {
+    const androidManifest = config.modResults;
+    const mainApplication = androidManifest.manifest;
+
+    // Ensure uses-feature array exists
+    if (!mainApplication['uses-feature']) {
+      mainApplication['uses-feature'] = [];
+    }
+
+    // Ensure uses-permission array exists
+    if (!mainApplication['uses-permission']) {
+      mainApplication['uses-permission'] = [];
+    }
+
+    // Add USB host feature for FLIR ONE USB devices
+    const usbHostFeature = {
+      $: {
+        'android:name': 'android.hardware.usb.host',
+        'android:required': 'false',
+      },
+    };
+
+    // Check if USB host feature already exists
+    const hasUsbHost = mainApplication['uses-feature'].some(
+      (feature) => feature.$?.['android:name'] === 'android.hardware.usb.host'
+    );
+
+    if (!hasUsbHost) {
+      mainApplication['uses-feature'].push(usbHostFeature);
+    }
+
+    // Add camera permission for FLIR cameras
+    const cameraPermission = {
+      $: {
+        'android:name': 'android.permission.CAMERA',
+      },
+    };
+
+    // Check if camera permission already exists
+    const hasCameraPermission = mainApplication['uses-permission'].some(
+      (permission) => permission.$?.['android:name'] === 'android.permission.CAMERA'
+    );
+
+    if (!hasCameraPermission) {
+      mainApplication['uses-permission'].push(cameraPermission);
+    }
+
+    return config;
+  });
+};
+
+/**
+ * Copies sdk-manifest.json to iOS project
+ */
+const withFlirManifest = (config) => {
+  return withDangerousMod(config, [
+    'ios',
+    async (config) => {
+      const src = path.join(__dirname, 'sdk-manifest.json');
+      const dst = path.join(config.modRequest.platformProjectRoot, 'sdk-manifest.json');
+      fs.copyFileSync(src, dst);
+      return config;
+    },
+  ]);
+};
+
+/**
+ * Copies sdk-manifest.json to Android assets
+ */
+const withFlirAndroidAssets = (config) => {
+  return withDangerousMod(config, [
+    'android',
+    async (config) => {
+      const src = path.join(__dirname, 'sdk-manifest.json');
+      const dst = path.join(config.modRequest.platformProjectRoot, 'app/src/main/assets/sdk-manifest.json');
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(src, dst);
+      return config;
+    },
+  ]);
+};
+
+/**
+ * Ensure the Flir Android Gradle module is included in generated projects.
+ *
+ * Some workflows (Expo prebuild) won't add node_modules subprojects to
+ * settings.gradle automatically unless the package exposes autolinking or
+ * the plugin performs the edit. When a consumer installs the package and
+ * runs prebuild, include the Flir module and wire an app dependency so the
+ * native bridge (FlirDownloadManager) is compiled into the app.
+ */
+const withFlirAndroidGradle = (config) => {
+  return withDangerousMod(config, [
+    'android',
+    async (config) => {
+      try {
+        const projectRoot = config.modRequest.platformProjectRoot;
+        const settingsGradlePath = path.join(projectRoot, 'settings.gradle');
+        const appBuildGradlePath = path.join(projectRoot, 'app', 'build.gradle');
+
+        const moduleRelPath = '../node_modules/ilabs-flir/android/Flir';
+        const includeSnippet = `\n// ilabs-flir: include Flir module\nif (new File(rootProject.projectDir, '${moduleRelPath}').exists()) {\n    include ':Flir'\n    project(':Flir').projectDir = new File(rootProject.projectDir, '${moduleRelPath}')\n}\n`;
+
+        if (fs.existsSync(settingsGradlePath)) {
+          let settingsTxt = fs.readFileSync(settingsGradlePath, 'utf8');
+          if (!/include\s*':Flir'/.test(settingsTxt)) {
+            fs.appendFileSync(settingsGradlePath, includeSnippet, 'utf8');
+          }
+        }
+
+        if (fs.existsSync(appBuildGradlePath)) {
+          let buildTxt = fs.readFileSync(appBuildGradlePath, 'utf8');
+          // Only add implementation project(':Flir') if it's not already present
+          if (!/project\('\:Flir'\)/.test(buildTxt)) {
+            const depSnippet = `\n    // ilabs-flir: include :Flir when available\n    if (new File(rootDir.getParent(), '${moduleRelPath}').exists()) {\n        implementation project(':Flir')\n    }\n`;
+
+            // Find the first 'dependencies {' occurrence and find its matching closing brace
+            const depIndex = buildTxt.search(/\bdependencies\s*\{/);
+            if (depIndex !== -1) {
+              // Walk forward to find the matching closing brace for the dependencies block
+              let depth = 0;
+              let insertPos = -1;
+              for (let i = depIndex; i < buildTxt.length; i++) {
+                const ch = buildTxt[i];
+                if (ch === '{') depth++;
+                else if (ch === '}') {
+                  depth--;
+                  if (depth === 0) { insertPos = i; break; }
+                }
+              }
+
+              if (insertPos !== -1) {
+                // Insert snippet just before the closing '}' of the dependencies block
+                buildTxt = buildTxt.slice(0, insertPos) + depSnippet + buildTxt.slice(insertPos);
+                fs.writeFileSync(appBuildGradlePath, buildTxt, 'utf8');
+              } else {
+                // Fallback: append to the file
+                fs.appendFileSync(appBuildGradlePath, '\n' + depSnippet, 'utf8');
+              }
+            } else {
+              // No dependencies block found! Append a new one with the snippet.
+              fs.appendFileSync(appBuildGradlePath, '\n' + 'dependencies {' + depSnippet + '\n}\n', 'utf8');
+            }
+          }
+        }
+      } catch (err) {
+        console.warn('[flir-config-plugin] Failed to patch Android Gradle files:', err && err.message);
+      }
+
+      return config;
+    },
+  ]);
+};
+
+/**
+ * Main plugin that combines iOS and Android configurations
+ */
+const withFlirThermalSDK = (config, props = {}) => {
+  // Apply iOS modifications
+  config = withFlirInfoPlist(config, props);
+  config = withFlirManifest(config);
+
+  // Apply Android modifications
+  config = withFlirAndroidManifest(config);
+  config = withFlirAndroidAssets(config);
+  // Ensure the Flir Gradle module is included in generated native projects
+  config = withFlirAndroidGradle(config);
+
+  return config;
+};
+
+module.exports = createRunOncePlugin(
+  withFlirThermalSDK,
+  'ilabs-flir',
+  '2.0.2'
+);

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+    "platforms": [
+        "android",
+        "ios"
+    ]
+}