@swiftpatch/react-native 2.0.0

package/android/src/main/java/com/swiftpatch/SlotManager.kt

@@ -0,0 +1,299 @@
+package com.swiftpatch
+
+import android.content.Context
+import android.content.SharedPreferences
+import java.io.File
+
+enum class SlotState(val value: String) {
+    DEFAULT_SLOT("DEFAULT_SLOT"),
+    STABLE_SLOT("STABLE_SLOT"),
+    NEW_SLOT("NEW_SLOT");
+
+    companion object {
+        fun from(value: String): SlotState = entries.find { it.value == value } ?: DEFAULT_SLOT
+    }
+}
+
+enum class EnvironmentMode(val value: String) {
+    PRODUCTION("PROD"),
+    STAGING("STAGE");
+
+    companion object {
+        fun from(value: String): EnvironmentMode = entries.find { it.value == value } ?: PRODUCTION
+    }
+}
+
+class SlotManager(private val context: Context, private val prefs: SharedPreferences) {
+
+    private val baseDir: File get() = File(context.filesDir, "swiftpatch")
+    private val prodDir: File get() = File(baseDir, "prod")
+    private val prodNewDir: File get() = File(prodDir, "new")
+    private val prodStableDir: File get() = File(prodDir, "stable")
+    private val stageDir: File get() = File(baseDir, "stage")
+    private val stageNewDir: File get() = File(stageDir, "new")
+
+    fun ensureSlotDirectories() {
+        prodNewDir.mkdirs()
+        prodStableDir.mkdirs()
+        stageNewDir.mkdirs()
+    }
+
+    // ═══ Current State ═══
+
+    var currentEnvironment: EnvironmentMode
+        get() = EnvironmentMode.from(prefs.getString("environment", "PROD") ?: "PROD")
+        set(value) = prefs.edit().putString("environment", value.value).apply()
+
+    var currentProdSlot: SlotState
+        get() = SlotState.from(prefs.getString("prod_current_slot", "DEFAULT_SLOT") ?: "DEFAULT_SLOT")
+        set(value) = prefs.edit().putString("prod_current_slot", value.value).apply()
+
+    var prodNewHash: String?
+        get() = prefs.getString("prod_new_hash", null)
+        set(value) {
+            if (value != null) prefs.edit().putString("prod_new_hash", value).apply()
+            else prefs.edit().remove("prod_new_hash").apply()
+        }
+
+    var prodStableHash: String?
+        get() = prefs.getString("prod_stable_hash", null)
+        set(value) {
+            if (value != null) prefs.edit().putString("prod_stable_hash", value).apply()
+            else prefs.edit().remove("prod_stable_hash").apply()
+        }
+
+    var prodTempHash: String?
+        get() = prefs.getString("prod_temp_hash", null)
+        set(value) {
+            if (value != null) prefs.edit().putString("prod_temp_hash", value).apply()
+            else prefs.edit().remove("prod_temp_hash").apply()
+        }
+
+    var stageNewHash: String?
+        get() = prefs.getString("stage_new_hash", null)
+        set(value) {
+            if (value != null) prefs.edit().putString("stage_new_hash", value).apply()
+            else prefs.edit().remove("stage_new_hash").apply()
+        }
+
+    // ═══ Bundle Path Resolution ═══
+
+    fun getBundleFile(): String? {
+        val env = currentEnvironment
+
+        if (env == EnvironmentMode.STAGING) {
+            val hash = stageNewHash ?: return null
+            val path = File(stageNewDir, "$hash.bundle")
+            return if (path.exists()) path.absolutePath else null
+        }
+
+        // Production mode
+        return when (currentProdSlot) {
+            SlotState.NEW_SLOT -> {
+                val hash = prodNewHash
+                if (hash != null) {
+                    val path = File(prodNewDir, "$hash.bundle")
+                    if (path.exists()) return path.absolutePath
+                }
+                // Fallthrough to stable
+                val stableHash = prodStableHash
+                if (stableHash != null) {
+                    val stablePath = File(prodStableDir, "$stableHash.bundle")
+                    if (stablePath.exists()) {
+                        currentProdSlot = SlotState.STABLE_SLOT
+                        return stablePath.absolutePath
+                    }
+                }
+                currentProdSlot = SlotState.DEFAULT_SLOT
+                null
+            }
+            SlotState.STABLE_SLOT -> {
+                val hash = prodStableHash
+                if (hash != null) {
+                    val path = File(prodStableDir, "$hash.bundle")
+                    if (path.exists()) return path.absolutePath
+                }
+                currentProdSlot = SlotState.DEFAULT_SLOT
+                null
+            }
+            SlotState.DEFAULT_SLOT -> null
+        }
+    }
+
+    // ═══ Temp Hash (Deferred Apply) ═══
+
+    fun applyTempHashOnLaunch() {
+        val tempHash = prodTempHash ?: return
+
+        val bundlesDir = File(baseDir, "bundles")
+        val sourcePath = File(bundlesDir, "$tempHash.bundle")
+        val destPath = File(prodNewDir, "$tempHash.bundle")
+
+        if (sourcePath.exists()) {
+            destPath.delete()
+            sourcePath.renameTo(destPath)
+        }
+
+        prodNewHash = tempHash
+        prodTempHash = null
+        currentProdSlot = SlotState.NEW_SLOT
+
+        prefs.edit().putString("current_bundle_installed_at",
+            java.time.Instant.now().toString()).apply()
+    }
+
+    // ═══ Stabilization (NEW → STABLE) ═══
+
+    fun stabilize(): Boolean {
+        val newHash = prodNewHash ?: return false
+
+        val sourcePath = File(prodNewDir, "$newHash.bundle")
+        val destPath = File(prodStableDir, "$newHash.bundle")
+
+        if (!sourcePath.exists()) return false
+
+        // Remove old stable bundle
+        prodStableHash?.let { oldHash ->
+            File(prodStableDir, "$oldHash.bundle").delete()
+        }
+
+        // Copy new bundle to stable
+        destPath.delete()
+        sourcePath.copyTo(destPath, overwrite = true)
+
+        prodStableHash = newHash
+        prodNewHash = null
+        currentProdSlot = SlotState.STABLE_SLOT
+
+        return true
+    }
+
+    // ═══ Rollback ═══
+
+    fun rollbackProd(isAutoRollback: Boolean): String {
+        return when (currentProdSlot) {
+            SlotState.NEW_SLOT -> {
+                prodNewHash?.let { hash ->
+                    File(prodNewDir, "$hash.bundle").delete()
+                }
+                prodNewHash = null
+                prodTempHash = null
+
+                if (prodStableHash != null) {
+                    currentProdSlot = SlotState.STABLE_SLOT
+                    "ROLLED_BACK_TO_STABLE"
+                } else {
+                    currentProdSlot = SlotState.DEFAULT_SLOT
+                    "ROLLED_BACK_TO_DEFAULT"
+                }
+            }
+            SlotState.STABLE_SLOT -> {
+                prodStableHash?.let { hash ->
+                    File(prodStableDir, "$hash.bundle").delete()
+                }
+                prodStableHash = null
+                currentProdSlot = SlotState.DEFAULT_SLOT
+                "ROLLED_BACK_TO_DEFAULT"
+            }
+            SlotState.DEFAULT_SLOT -> "ALREADY_AT_DEFAULT"
+        }
+    }
+
+    fun rollbackStage() {
+        stageNewHash?.let { hash ->
+            File(stageNewDir, "$hash.bundle").delete()
+        }
+        stageNewHash = null
+    }
+
+    // ═══ Version Change Detection ═══
+
+    fun checkVersionChange(): Boolean {
+        val currentAppVersion = try {
+            context.packageManager.getPackageInfo(context.packageName, 0).versionName ?: "0.0.0"
+        } catch (_: Exception) { "0.0.0" }
+
+        val lastKnownVersion = prefs.getString("last_known_app_version", null)
+
+        if (lastKnownVersion != null && lastKnownVersion != currentAppVersion) {
+            fallbackToDefault()
+            prefs.edit().putString("last_known_app_version", currentAppVersion).apply()
+            return true
+        }
+
+        if (lastKnownVersion == null) {
+            prefs.edit().putString("last_known_app_version", currentAppVersion).apply()
+        }
+
+        return false
+    }
+
+    fun fallbackToDefault() {
+        prodNewHash = null
+        prodStableHash = null
+        prodTempHash = null
+        stageNewHash = null
+        currentProdSlot = SlotState.DEFAULT_SLOT
+
+        // Clear legacy keys
+        prefs.edit()
+            .remove("current_bundle_hash")
+            .remove("current_bundle_path")
+            .remove("previous_bundle_hash")
+            .remove("previous_bundle_path")
+            .remove("pending_bundle_hash")
+            .remove("pending_bundle_path")
+            .remove("pending_install_confirmation")
+            .putInt("crash_count", 0)
+            .apply()
+
+        // Delete all bundle directories
+        prodNewDir.deleteRecursively()
+        prodStableDir.deleteRecursively()
+        stageNewDir.deleteRecursively()
+
+        ensureSlotDirectories()
+    }
+
+    // ═══ Metadata ═══
+
+    fun getMetadata(): Map<String, Any?> {
+        return mapOf(
+            "environment" to currentEnvironment.value,
+            "prod" to mapOf(
+                "currentSlot" to currentProdSlot.value,
+                "newHash" to prodNewHash,
+                "stableHash" to prodStableHash,
+                "tempHash" to prodTempHash,
+            ),
+            "stage" to mapOf(
+                "newHash" to stageNewHash,
+            )
+        )
+    }
+
+    // ═══ Cleanup ═══
+
+    fun cleanup() {
+        val keepHashes = setOfNotNull(prodNewHash, prodStableHash, stageNewHash)
+
+        cleanDirectory(prodNewDir, keepHashes)
+        cleanDirectory(prodStableDir, keepHashes)
+        cleanDirectory(stageNewDir, keepHashes)
+
+        // Clean legacy bundles dir
+        cleanDirectory(File(baseDir, "bundles"), keepHashes)
+
+        // Clean temp
+        File(baseDir, "temp").listFiles()?.forEach { it.delete() }
+    }
+
+    private fun cleanDirectory(dir: File, keepHashes: Set<String>) {
+        dir.listFiles()?.forEach { file ->
+            val fileHash = file.nameWithoutExtension
+            if (fileHash !in keepHashes) {
+                file.delete()
+            }
+        }
+    }
+}