ilabs-flir 1.0.3 → 1.0.5

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

@@ -1,195 +1,84 @@
-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 - look for either file from the manifest
-        val sdkDir = getSDKDirectory(context)
-        return File(sdkDir, "thermalsdk-release.aar").exists() || 
-               File(sdkDir, "androidsdk-release.aar").exists() ||
-               File(sdkDir, "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 flir.android
+
+import android.content.Context
+import android.os.Build
+import android.util.Log
+
+/**
+ * FlirSDKLoader - SDK availability checker
+ * 
+ * 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"
+    
+    /**
+     * Get the primary ABI for this device
+     */
+    fun getDeviceArch(): String {
+        val supportedAbis = Build.SUPPORTED_ABIS
+        Log.d(TAG, "Device supported ABIs: ${supportedAbis.joinToString()}")
+        
+        val knownArchs = setOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
+        for (abi in supportedAbis) {
+            if (abi in knownArchs) {
+                Log.d(TAG, "Selected ABI: $abi")
+                return abi
+            }
+        }
+        return "arm64-v8a"
+    }
+    
+    /**
+     * Check if SDK is available - always true since bundled in AAR
+     */
+    fun isSDKAvailable(context: Context): Boolean {
+        Log.d(TAG, "SDK is bundled in AAR - always available")
+        return true
+    }
+    
+    /**
+     * No download needed - SDK is bundled
+     */
+    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 SDK status
+     */
+    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
+        )
+    }
+    
+    /**
+     * Get DEX path - not applicable when bundled via AAR
+     * Returns null since SDK is bundled in AAR, no separate DEX needed
+     */
+    fun getDexPath(context: Context): java.io.File? {
+        // SDK is bundled in AAR - no separate DEX file
+        return null
+    }
+    
+    /**
+     * Get native library directory - not applicable when bundled via AAR
+     * Returns null since native libs are included in AAR and handled by Android
+     */
+    fun getNativeLibDir(context: Context): java.io.File? {
+        // SDK native libs are bundled in AAR and extracted automatically by Android
+        return null
+    }
+}