@viettelpost/react-native-ota 0.1.0

package/android/src/main/java/com/viettelpost/otakit/OTAUpdateCleanup.kt

@@ -0,0 +1,186 @@
+package com.viettelpost.otakit
+
+import android.content.Context
+import android.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+object OTAUpdateCleanup {
+    private const val TAG = "OTAKit"
+    private const val EMBEDDED_VERSION = "embedded"
+    private const val BUNDLES_DIR_NAME = "bundles"
+    private const val TMP_DIR_NAME = "tmp"
+    private const val METADATA_FILE_NAME = "metadata.json"
+
+    fun cleanupAfterSuccessfulActivation(context: Context, activeVersion: String): Boolean {
+        if (isEmbeddedVersion(activeVersion)) {
+            return cleanupOrphanedBundles(context, emptySet())
+        }
+        return cleanupOrphanedBundles(context, setOf(activeVersion))
+    }
+
+    fun cleanupFailedPendingBundle(context: Context, failedVersion: String?): Boolean {
+        if (isEmbeddedVersion(failedVersion)) {
+            return true
+        }
+        val version = failedVersion.orEmpty()
+        val bundleDeleted = safeDeleteUnderOTARoot(context, bundleDirectory(context, version))
+        val tempDeleted = cleanupTemp(context, version)
+        return bundleDeleted && tempDeleted
+    }
+
+    fun cleanupTemp(context: Context, version: String?): Boolean {
+        if (version.isNullOrBlank()) {
+            return true
+        }
+        return safeDeleteUnderOTARoot(context, tempDirectory(context, version))
+    }
+
+    fun cleanupAllTemp(context: Context): Boolean =
+        safeDeleteChildrenUnderOTARoot(tmpRoot(context))
+
+    fun cleanupOrphanedBundles(context: Context, keepVersions: Set<String>): Boolean {
+        val normalizedKeepVersions = keepVersions
+            .filterNot { isEmbeddedVersion(it) }
+            .toSet()
+        return safeDeleteChildrenUnderOTARoot(bundleRoot(context)) { child ->
+            child.name !in normalizedKeepVersions
+        }
+    }
+
+    fun cleanupOTAStorage(context: Context): Boolean {
+        val metadata = OTAUpdateStorage.readMetadata(context)
+        val keepVersions = mutableSetOf<String>()
+        if (!isEmbeddedVersion(metadata.activeBundleVersion)) {
+            keepVersions.add(metadata.activeBundleVersion)
+        }
+        if (!isEmbeddedVersion(metadata.pendingBundleVersion)) {
+            keepVersions.add(metadata.pendingBundleVersion.orEmpty())
+        }
+
+        var didCleanup = cleanupAllTemp(context)
+        if (!isEmbeddedVersion(metadata.failedBundleVersion) &&
+            metadata.failedBundleVersion !in keepVersions
+        ) {
+            didCleanup = cleanupFailedPendingBundle(context, metadata.failedBundleVersion) && didCleanup
+        }
+        didCleanup = cleanupOrphanedBundles(context, keepVersions) && didCleanup
+        return didCleanup
+    }
+
+    fun getOTADiskUsage(context: Context): JSONObject {
+        val metadata = OTAUpdateStorage.readMetadata(context)
+        val otaRoot = OTAUpdateBundleResolver.otaDirectory(context)
+        val tmpRoot = tmpRoot(context)
+        val bundlesRoot = bundleRoot(context)
+        val bundles = JSONArray()
+
+        bundlesRoot.listFiles()
+            ?.filter { it.isDirectory }
+            ?.sortedBy { it.name }
+            ?.forEach { directory ->
+                bundles.put(
+                    JSONObject().apply {
+                        put("version", directory.name)
+                        put("bytes", directorySize(directory))
+                        put("isActive", directory.name == metadata.activeBundleVersion)
+                        put("isPending", directory.name == metadata.pendingBundleVersion)
+                        put("isFailed", directory.name == metadata.failedBundleVersion)
+                    },
+                )
+            }
+
+        return JSONObject().apply {
+            put("otaRootPath", otaRoot.absolutePath)
+            put("totalBytes", directorySize(otaRoot))
+            put("tmpBytes", directorySize(tmpRoot))
+            put("bundlesBytes", directorySize(bundlesRoot))
+            put("bundles", bundles)
+        }
+    }
+
+    fun deleteFinalBundleForFailedInstall(context: Context, version: String?): Boolean {
+        if (isEmbeddedVersion(version)) {
+            return true
+        }
+        return safeDeleteUnderOTARoot(context, bundleDirectory(context, version.orEmpty()))
+    }
+
+    private fun safeDeleteChildrenUnderOTARoot(
+        directory: File,
+        shouldDelete: (File) -> Boolean = { true },
+    ): Boolean {
+        if (!directory.exists()) {
+            return true
+        }
+        val children = directory.listFiles() ?: return true
+        var didDeleteAll = true
+        children.forEach { child ->
+            if (shouldDelete(child)) {
+                didDeleteAll = safeDeleteUnderOTARoot(directory.parentFile ?: directory, child) && didDeleteAll
+            }
+        }
+        return didDeleteAll
+    }
+
+    private fun safeDeleteUnderOTARoot(context: Context, target: File): Boolean =
+        safeDeleteUnderOTARoot(OTAUpdateBundleResolver.otaDirectory(context), target)
+
+    private fun safeDeleteUnderOTARoot(otaRoot: File, target: File): Boolean {
+        if (!target.exists()) {
+            return true
+        }
+
+        return try {
+            val rootPath = otaRoot.canonicalFile.toPath()
+            val targetPath = target.canonicalFile.toPath()
+
+            // Cleanup must never remove metadata, the OTA root, or any path outside OTA storage.
+            if (target.name == METADATA_FILE_NAME || targetPath == rootPath || !targetPath.startsWith(rootPath)) {
+                Log.w(TAG, "OTA cleanup refused unsafe delete; path=${target.absolutePath}")
+                return false
+            }
+
+            if (!target.deleteRecursively()) {
+                Log.w(TAG, "OTA cleanup could not delete ${target.absolutePath}")
+                return false
+            }
+            Log.d(TAG, "OTA cleanup deleted ${target.absolutePath}")
+            true
+        } catch (error: Exception) {
+            Log.w(TAG, "OTA cleanup failed for ${target.absolutePath}", error)
+            false
+        }
+    }
+
+    private fun directorySize(file: File): Long {
+        if (!file.exists()) {
+            return 0L
+        }
+        if (file.isFile) {
+            return file.length()
+        }
+
+        var total = 0L
+        file.listFiles()?.forEach { child ->
+            total += directorySize(child)
+        }
+        return total
+    }
+
+    private fun bundleRoot(context: Context): File =
+        File(OTAUpdateBundleResolver.otaDirectory(context), BUNDLES_DIR_NAME)
+
+    private fun tmpRoot(context: Context): File =
+        File(OTAUpdateBundleResolver.otaDirectory(context), TMP_DIR_NAME)
+
+    private fun bundleDirectory(context: Context, version: String): File =
+        File(bundleRoot(context), version)
+
+    private fun tempDirectory(context: Context, version: String): File =
+        File(tmpRoot(context), version)
+
+    private fun isEmbeddedVersion(version: String?): Boolean =
+        version.isNullOrBlank() || version == EMBEDDED_VERSION
+}