ilabs-flir 1.0.4 → 1.0.6

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

@@ -1,12 +1,35 @@
 package flir.android
 
+import android.util.Log
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.modules.core.DeviceEventManagerModule
 
 class FlirModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    
+    companion object {
+        private const val TAG = "FlirModule"
+    }
+    
     override fun getName(): String = "FlirModule"
+    
+    // Required for RN event emitter support
+    private var listenerCount = 0
+    
+    @ReactMethod
+    fun addListener(eventName: String) {
+        listenerCount++
+        Log.d(TAG, "addListener: $eventName (count: $listenerCount)")
+    }
+    
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        listenerCount -= count
+        if (listenerCount < 0) listenerCount = 0
+        Log.d(TAG, "removeListeners: $count (remaining: $listenerCount)")
+    }
 
     // Simple placeholder conversion: converts an ARGB color to a pseudo-temperature value.
     // Replace with SDK call when integrating thermalsdk APIs.
@@ -71,4 +94,164 @@ 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)
+        }
+    }
+    
+    @ReactMethod
+    fun getDiscoveredDevices(promise: Promise) {
+        try {
+            val devices = FlirManager.getDiscoveredDevices()
+            val result = com.facebook.react.bridge.Arguments.createArray()
+            
+            devices.forEach { identity ->
+                val deviceMap = com.facebook.react.bridge.Arguments.createMap()
+                deviceMap.putString("id", identity.deviceId)
+                deviceMap.putString("name", identity.deviceId)
+                deviceMap.putString("communicationType", identity.communicationInterface.name)
+                deviceMap.putBoolean("isEmulator", identity.communicationInterface.name == "EMULATOR")
+                result.pushMap(deviceMap)
+            }
+            
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_DEVICES", e)
+        }
+    }
+    
+    @ReactMethod
+    fun startEmulator(emulatorType: String, promise: Promise) {
+        try {
+            // Ensure SDK is initialized with context before starting discovery
+            FlirManager.init(reactContext)
+            // With simplified API, just start discovery - emulators are discovered like any device
+            FlirManager.startDiscovery(true)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_EMULATOR", e)
+        }
+    }
+    
+    @ReactMethod
+    fun connectToDevice(deviceId: String, promise: Promise) {
+        try {
+            // Ensure SDK is initialized with context before connecting
+            FlirManager.init(reactContext)
+            FlirManager.connectToDevice(deviceId)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_CONNECT", e)
+        }
+    }
+    
+    @ReactMethod
+    fun startDiscovery(promise: Promise) {
+        try {
+            // Ensure SDK is initialized with context before starting discovery
+            FlirManager.init(reactContext)
+            FlirManager.startDiscovery(true)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_DISCOVERY", e)
+        }
+    }
+    
+    @ReactMethod
+    fun stopDiscovery(promise: Promise) {
+        try {
+            FlirManager.stopDiscovery()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_STOP_DISCOVERY", e)
+        }
+    }
+    
+    @ReactMethod
+    fun stopFlir(promise: Promise) {
+        try {
+            FlirManager.stop()
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("ERR_FLIR_STOP", e)
+        }
+    }
+    
+    @ReactMethod
+    fun initializeSDK(promise: Promise) {
+        try {
+            FlirManager.init(reactContext)
+            
+            val result = com.facebook.react.bridge.Arguments.createMap()
+            result.putBoolean("initialized", true)
+            result.putString("message", "SDK initialized successfully")
+            promise.resolve(result)
+        } catch (e: Exception) {
+            val result = com.facebook.react.bridge.Arguments.createMap()
+            result.putBoolean("initialized", false)
+            result.putString("error", e.message ?: "Unknown error")
+            result.putString("errorType", e.javaClass.simpleName)
+            promise.resolve(result)
+        }
+    }
+    
+    @ReactMethod
+    fun getDebugInfo(promise: Promise) {
+        try {
+            val result = com.facebook.react.bridge.Arguments.createMap()
+            
+            // SDK availability
+            result.putBoolean("sdkAvailable", FlirSDKLoader.isSDKAvailable(reactContext))
+            result.putString("arch", FlirSDKLoader.getDeviceArch())
+            
+            // Check if FLIR SDK classes are loadable
+            val classesLoaded = try {
+                Class.forName("com.flir.thermalsdk.androidsdk.ThermalSdkAndroid")
+                Class.forName("com.flir.thermalsdk.live.discovery.DiscoveryFactory")
+                true
+            } catch (e: ClassNotFoundException) {
+                false
+            }
+            result.putBoolean("sdkClassesLoaded", classesLoaded)
+            
+            // Discovery state
+            val devices = FlirManager.getDiscoveredDevices()
+            result.putInt("discoveredDeviceCount", devices.size)
+            result.putBoolean("isConnected", FlirManager.isConnected())
+            result.putBoolean("isStreaming", FlirManager.isStreaming())
+            result.putString("connectedDevice", FlirManager.getConnectedDeviceInfo())
+            
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("ERR_DEBUG_INFO", e)
+        }
+    }
 }

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

@@ -3,67 +3,18 @@ package flir.android
 import android.content.Context
 import android.os.Build
 import android.util.Log
-import kotlinx.coroutines.*
-import org.json.JSONObject
-import java.io.File
-import java.io.FileOutputStream
-import java.net.HttpURLConnection
-import java.net.URL
-import java.util.zip.ZipInputStream
 
 /**
- * FlirSDKLoader - Downloads and manages architecture-specific FLIR SDK packages
+ * FlirSDKLoader - SDK availability checker
  * 
- * Each package contains:
- * - classes.dex (combined DEX from thermalsdk + androidsdk)
- * - Native .so libraries in jni/{arch}/ folder
- * 
- * URLs are read from sdk-manifest.json in assets folder
+ * Since the SDK is now bundled via AAR files, this class simply reports
+ * that the SDK is always available. The AAR files include native .so libraries
+ * for all supported architectures, which Android handles automatically.
  */
 object FlirSDKLoader {
     
     private const val TAG = "FlirSDKLoader"
     
-    // Cached manifest data
-    private var cachedManifest: SDKManifest? = null
-    
-    // Manifest data classes
-    data class ArchPackage(val downloadUrl: String, val sizeBytes: Long)
-    data class SDKManifest(val version: String, val packages: Map<String, ArchPackage>)
-    
-    private fun getSDKDirectory(context: Context) = File(context.filesDir, "FlirSDK")
-    
-    /**
-     * Load manifest from assets
-     */
-    private fun loadManifest(context: Context): SDKManifest? {
-        if (cachedManifest != null) return cachedManifest
-        
-        return try {
-            val json = context.assets.open("sdk-manifest.json").bufferedReader().readText()
-            val root = JSONObject(json)
-            val android = root.getJSONObject("android")
-            val packagesJson = android.getJSONObject("packages")
-            
-            val packages = mutableMapOf<String, ArchPackage>()
-            packagesJson.keys().forEach { arch ->
-                val pkg = packagesJson.getJSONObject(arch)
-                packages[arch] = ArchPackage(
-                    downloadUrl = pkg.getString("downloadUrl"),
-                    sizeBytes = pkg.getLong("sizeBytes")
-                )
-            }
-            
-            SDKManifest(
-                version = root.getString("version"),
-                packages = packages
-            ).also { cachedManifest = it }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to load manifest: ${e.message}")
-            null
-        }
-    }
-    
     /**
      * Get the primary ABI for this device
      */
@@ -71,7 +22,7 @@ object FlirSDKLoader {
         val supportedAbis = Build.SUPPORTED_ABIS
         Log.d(TAG, "Device supported ABIs: ${supportedAbis.joinToString()}")
         
-        val knownArchs = setOf("arm64-v8a", "armeabi-v7a", "x86_64")
+        val knownArchs = setOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
         for (abi in supportedAbis) {
             if (abi in knownArchs) {
                 Log.d(TAG, "Selected ABI: $abi")
@@ -82,162 +33,52 @@ object FlirSDKLoader {
     }
     
     /**
-     * Check if SDK is already downloaded
+     * Check if SDK is available - always true since bundled in AAR
      */
     fun isSDKAvailable(context: Context): Boolean {
-        val sdkDir = getSDKDirectory(context)
-        val arch = getDeviceArch()
-        
-        val dexFile = File(sdkDir, "classes.dex")
-        val soDir = File(sdkDir, "jni/$arch")
-        
-        val hasDex = dexFile.exists() && dexFile.length() > 0
-        val hasSo = soDir.exists() && soDir.listFiles()?.isNotEmpty() == true
-        
-        Log.d(TAG, "SDK available: dex=$hasDex, so=$hasSo")
-        return hasDex && hasSo
+        Log.d(TAG, "SDK is bundled in AAR - always available")
+        return true
     }
     
     /**
-     * Get path to the DEX file
+     * No download needed - SDK is bundled
      */
-    fun getDexPath(context: Context): File? {
-        val dexFile = File(getSDKDirectory(context), "classes.dex")
-        return if (dexFile.exists()) dexFile else null
-    }
-    
-    /**
-     * Get path to native libraries directory
-     */
-    fun getNativeLibDir(context: Context): File? {
-        val arch = getDeviceArch()
-        val libDir = File(getSDKDirectory(context), "jni/$arch")
-        return if (libDir.exists()) libDir else null
+    suspend fun downloadSDK(
+        context: Context,
+        onProgress: ((progress: Int, bytesDownloaded: Long, totalBytes: Long) -> Unit)? = null
+    ): Boolean {
+        Log.d(TAG, "SDK is bundled - no download needed")
+        onProgress?.invoke(100, 0, 0)
+        return true
     }
     
     /**
-     * Get estimated download size from manifest
+     * Get SDK status
      */
-    fun getDownloadSize(context: Context): Long {
-        val manifest = loadManifest(context) ?: return 15_000_000L
-        val arch = getDeviceArch()
-        return manifest.packages[arch]?.sizeBytes ?: 15_000_000L
+    fun getSDKStatus(context: Context): Map<String, Any> {
+        return mapOf(
+            "available" to true,
+            "bundled" to true,
+            "arch" to getDeviceArch(),
+            "version" to "4.16.0" // SDK version from AAR
+        )
     }
     
     /**
-     * Download the SDK package for this device's architecture
+     * Get DEX path - not applicable when bundled via AAR
+     * Returns null since SDK is bundled in AAR, no separate DEX needed
      */
-    suspend fun downloadSDK(
-        context: Context,
-        onProgress: (downloaded: Long, total: Long) -> Unit
-    ): Result<Unit> = withContext(Dispatchers.IO) {
-        try {
-            val arch = getDeviceArch()
-            val manifest = loadManifest(context) 
-                ?: return@withContext Result.failure(Exception("Failed to load manifest"))
-            
-            val archPackage = manifest.packages[arch]
-                ?: return@withContext Result.failure(Exception("No package for architecture: $arch"))
-            
-            val downloadUrl = archPackage.downloadUrl
-            Log.i(TAG, "Downloading SDK for $arch from $downloadUrl")
-            
-            val sdkDir = getSDKDirectory(context).apply { mkdirs() }
-            val zipFile = File(context.cacheDir, "flir-sdk-$arch.zip")
-            
-            // Download with redirect handling (GitHub uses 302 redirects)
-            var connection = URL(downloadUrl).openConnection() as HttpURLConnection
-            connection.instanceFollowRedirects = true
-            connection.connectTimeout = 30000
-            connection.readTimeout = 60000
-            
-            // Handle redirects manually for cross-protocol redirects
-            var redirectCount = 0
-            while (connection.responseCode in 301..302 && redirectCount < 5) {
-                val redirectUrl = connection.getHeaderField("Location")
-                Log.d(TAG, "Redirect to: $redirectUrl")
-                connection.disconnect()
-                connection = URL(redirectUrl).openConnection() as HttpURLConnection
-                connection.instanceFollowRedirects = true
-                redirectCount++
-            }
-            
-            if (connection.responseCode != HttpURLConnection.HTTP_OK) {
-                return@withContext Result.failure(Exception("HTTP error ${connection.responseCode}"))
-            }
-            
-            val totalSize = connection.contentLengthLong.let { 
-                if (it > 0) it else archPackage.sizeBytes
-            }
-            
-            connection.inputStream.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)
-                        }
-                    }
-                }
-            }
-            connection.disconnect()
-            
-            Log.i(TAG, "Download complete: ${zipFile.length()} bytes")
-            
-            // Extract
-            unzip(zipFile, sdkDir)
-            zipFile.delete()
-            
-            // Verify
-            val dexFile = File(sdkDir, "classes.dex")
-            val soDir = File(sdkDir, "jni/$arch")
-            
-            if (!dexFile.exists()) {
-                return@withContext Result.failure(Exception("DEX file not extracted"))
-            }
-            
-            dexFile.setReadOnly()
-            Log.i(TAG, "SDK installed: dex=${dexFile.length()} bytes, libs=${soDir.listFiles()?.size ?: 0} files")
-            
-            Result.success(Unit)
-        } catch (e: Exception) {
-            Log.e(TAG, "Download failed", e)
-            Result.failure(e)
-        }
+    fun getDexPath(context: Context): java.io.File? {
+        // SDK is bundled in AAR - no separate DEX file
+        return null
     }
     
     /**
-     * Delete downloaded SDK
+     * Get native library directory - not applicable when bundled via AAR
+     * Returns null since native libs are included in AAR and handled by Android
      */
-    fun deleteSDK(context: Context): Boolean {
-        return getSDKDirectory(context).deleteRecursively()
-    }
-    
-    private fun unzip(source: File, destination: File) {
-        Log.d(TAG, "Extracting ${source.name} to ${destination.absolutePath}")
-        
-        ZipInputStream(source.inputStream()).use { zip ->
-            var entry = zip.nextEntry
-            while (entry != null) {
-                val file = File(destination, entry.name)
-                Log.d(TAG, "  Extracting: ${entry.name}")
-                
-                if (entry.isDirectory) {
-                    file.mkdirs()
-                } else {
-                    file.parentFile?.mkdirs()
-                    file.outputStream().use { output ->
-                        zip.copyTo(output)
-                    }
-                }
-                zip.closeEntry()
-                entry = zip.nextEntry
-            }
-        }
+    fun getNativeLibDir(context: Context): java.io.File? {
+        // SDK native libs are bundled in AAR and extracted automatically by Android
+        return null
     }
-}
+}