ilabs-flir 1.0.4 → 1.0.5

package/android/Flir/build.gradle.kts

@@ -14,21 +14,20 @@ android {
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
+   compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
     }
 
     kotlinOptions {
-        jvmTarget = "17"
+        jvmTarget = JavaVersion.VERSION_21.toString()
     }
-    
-    java {
-        toolchain {
-            languageVersion.set(JavaLanguageVersion.of(21))
-        }
+
+    buildFeatures {
+        viewBinding = true
     }
 
+   
     publishing {
         singleVariant("release") {
             withJavadocJar()
@@ -37,35 +36,23 @@ android {
     }
 }
 
-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
+    // Kotlin coroutines
     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 - Use stub JAR for compilation (AARs are Java 21, stubs work with Java 17)
-    // The actual SDK AARs are downloaded on-demand at runtime via FlirDownload.download()
-    compileOnly(files("libs/flir-stubs.jar"))
+    // FLIR SDK - Use the actual AAR files from libs folder
+    // Using 'api' to expose SDK classes to consumers and Java source files
+    // flatDir must be configured in settings.gradle or root build.gradle
+    api(files("libs/androidsdk-release.aar"))
+    api(files("libs/thermalsdk-release.aar"))
     
     // 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")
     }

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

@@ -1,25 +1,28 @@
 package flir.android
 
 import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import kotlinx.coroutines.*
 
+/**
+ * FlirDownloadManager - React Native module for SDK status
+ * 
+ * Since the SDK is now bundled in the AAR, this module just reports
+ * that the SDK is always available.
+ */
 class FlirDownloadManager(private val reactContext: ReactApplicationContext) : 
     ReactContextBaseJavaModule(reactContext) {
     
-    private var downloadJob: Job? = null
-    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-    
     override fun getName() = "FlirDownloadManager"
     
     @ReactMethod
     fun isFlirAvailable(promise: Promise) {
-        promise.resolve(FlirSDKLoader.isSDKAvailable(reactContext))
+        // SDK is bundled - always available
+        promise.resolve(true)
     }
     
     @ReactMethod
     fun getDownloadSize(promise: Promise) {
-        promise.resolve(FlirSDKLoader.getDownloadSize(reactContext).toDouble())
+        // No download needed
+        promise.resolve(0.0)
     }
     
     @ReactMethod
@@ -29,48 +32,24 @@ class FlirDownloadManager(private val reactContext: ReactApplicationContext) :
     
     @ReactMethod
     fun downloadFlirSDK(promise: Promise) {
-        downloadJob = scope.launch {
-            val result = FlirSDKLoader.downloadSDK(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()
+        // SDK is bundled - no download needed
+        promise.resolve(true)
     }
     
     @ReactMethod
-    fun deleteSDK(promise: Promise) {
-        promise.resolve(FlirSDKLoader.deleteSDK(reactContext))
+    fun getSDKStatus(promise: Promise) {
+        val status = Arguments.createMap().apply {
+            putBoolean("available", true)
+            putBoolean("bundled", true)
+            putString("arch", FlirSDKLoader.getDeviceArch())
+            putString("version", "4.16.0")
+        }
+        promise.resolve(status)
     }
     
     @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)
+    fun cancelDownload(promise: Promise) {
+        // Nothing to cancel
+        promise.resolve(true)
     }
 }

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)
+        }
+    }
 }

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
     }
-}
+}