@hot-updater/react-native 0.27.1 → 0.29.0

package/android/src/main/java/com/hotupdater/BundleMetadata.kt

@@ -14,8 +14,6 @@ data class BundleMetadata(
     val stableBundleId: String? = null,
     val stagingBundleId: String? = null,
     val verificationPending: Boolean = false,
-    val verificationAttemptedAt: Long? = null,
-    val stagingExecutionCount: Int? = null,
     val updatedAt: Long = System.currentTimeMillis(),
 ) {
     companion object {
@@ -45,18 +43,6 @@ data class BundleMetadata(
                         null
                     },
                 verificationPending = json.optBoolean("verificationPending", false),
-                verificationAttemptedAt =
-                    if (json.has("verificationAttemptedAt") && !json.isNull("verificationAttemptedAt")) {
-                        json.getLong("verificationAttemptedAt")
-                    } else {
-                        null
-                    },
-                stagingExecutionCount =
-                    if (json.has("stagingExecutionCount") && !json.isNull("stagingExecutionCount")) {
-                        json.getInt("stagingExecutionCount")
-                    } else {
-                        null
-                    },
                 updatedAt = json.optLong("updatedAt", System.currentTimeMillis()),
             )
 
@@ -100,8 +86,6 @@ data class BundleMetadata(
             put("stableBundleId", stableBundleId ?: JSONObject.NULL)
             put("stagingBundleId", stagingBundleId ?: JSONObject.NULL)
             put("verificationPending", verificationPending)
-            put("verificationAttemptedAt", verificationAttemptedAt ?: JSONObject.NULL)
-            put("stagingExecutionCount", stagingExecutionCount ?: JSONObject.NULL)
             put("updatedAt", updatedAt)
         }
 
@@ -237,3 +221,76 @@ data class CrashedHistory(
         bundles.clear()
     }
 }
+
+data class PendingCrashRecovery(
+    val launchedBundleId: String?,
+    val shouldRollback: Boolean,
+) {
+    companion object {
+        fun fromJson(json: JSONObject): PendingCrashRecovery =
+            PendingCrashRecovery(
+                launchedBundleId =
+                    if (json.has("bundleId") && !json.isNull("bundleId")) {
+                        json.getString("bundleId").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
+                shouldRollback = json.optBoolean("shouldRollback", false),
+            )
+    }
+}
+
+data class LaunchSelection(
+    val bundleUrl: String,
+    val launchedBundleId: String?,
+    val shouldRollbackOnCrash: Boolean,
+)
+
+data class LaunchReport(
+    val status: String = "STABLE",
+    val crashedBundleId: String? = null,
+) {
+    companion object {
+        private const val TAG = "LaunchReport"
+        const val LAUNCH_REPORT_FILENAME = "launch-report.json"
+
+        fun fromJson(json: JSONObject): LaunchReport =
+            LaunchReport(
+                status = json.optString("status", "STABLE"),
+                crashedBundleId =
+                    if (json.has("crashedBundleId") && !json.isNull("crashedBundleId")) {
+                        json.getString("crashedBundleId").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
+            )
+
+        fun loadFromFile(file: File): LaunchReport? =
+            try {
+                if (!file.exists()) {
+                    null
+                } else {
+                    fromJson(JSONObject(file.readText()))
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load launch report", e)
+                null
+            }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("status", status)
+            put("crashedBundleId", crashedBundleId ?: JSONObject.NULL)
+        }
+
+    fun saveToFile(file: File): Boolean =
+        try {
+            file.parentFile?.mkdirs()
+            file.writeText(toJson().toString(2))
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to save launch report", e)
+            false
+        }
+}

package/android/src/main/java/com/hotupdater/CohortService.kt

@@ -0,0 +1,73 @@
+package com.hotupdater
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.provider.Settings
+import java.util.UUID
+
+class CohortService(
+    private val context: Context,
+) {
+    private val prefs: SharedPreferences =
+        context.getSharedPreferences("HotUpdaterCohort", Context.MODE_PRIVATE)
+
+    companion object {
+        // Keep the legacy key so existing custom cohorts continue to work.
+        private const val COHORT_KEY = "custom_cohort"
+        private const val FALLBACK_IDENTIFIER_KEY = "fallback_identifier"
+    }
+
+    private fun hashString(value: String): Int {
+        var hash = 0
+        for (char in value) {
+            hash = (hash shl 5) - hash + char.code
+        }
+        return hash
+    }
+
+    private fun defaultNumericCohort(identifier: String): String {
+        val hash = hashString(identifier)
+        val normalized = ((hash % 1000) + 1000) % 1000
+        return (normalized + 1).toString()
+    }
+
+    private fun fallbackIdentifier(): String {
+        val fallback = prefs.getString(FALLBACK_IDENTIFIER_KEY, null)
+        if (!fallback.isNullOrEmpty()) {
+            return fallback
+        }
+
+        val generated = UUID.randomUUID().toString()
+        prefs.edit().putString(FALLBACK_IDENTIFIER_KEY, generated).apply()
+        return generated
+    }
+
+    fun setCohort(cohort: String) {
+        if (cohort.isEmpty()) {
+            return
+        }
+        prefs.edit().putString(COHORT_KEY, cohort).apply()
+    }
+
+    fun getCohort(): String {
+        val cohort = prefs.getString(COHORT_KEY, null)
+        if (!cohort.isNullOrEmpty()) {
+            return cohort
+        }
+
+        val androidId =
+            Settings.Secure.getString(
+                context.contentResolver,
+                Settings.Secure.ANDROID_ID,
+            )
+        val initialCohort =
+            if (!androidId.isNullOrEmpty()) {
+                defaultNumericCohort(androidId)
+            } else {
+                defaultNumericCohort(fallbackIdentifier())
+            }
+
+        prefs.edit().putString(COHORT_KEY, initialCohort).apply()
+        return initialCohort
+    }
+}

package/android/src/main/java/com/hotupdater/DecompressService.kt

@@ -12,14 +12,14 @@ class DecompressService {
         private const val TAG = "DecompressService"
     }
 
-    // Array of available strategies in order of detection priority
-    // Order matters: Try ZIP first (clear magic bytes), then TAR.GZ (GZIP magic bytes), then TAR.BR (fallback)
-    private val strategies =
+    // Strategies with reliable file signatures that can be validated cheaply.
+    // TAR.BR is attempted only as the final fallback because Brotli has no reliable magic bytes.
+    private val signatureStrategies =
         listOf(
             ZipDecompressionStrategy(),
             TarGzDecompressionStrategy(),
-            TarBrDecompressionStrategy(),
         )
+    private val tarBrStrategy = TarBrDecompressionStrategy()
 
     /**
      * Extracts a compressed file to the destination directory.
@@ -39,45 +39,51 @@ class DecompressService {
         val fileName = file.name
         val fileSize = if (file.exists()) file.length() else 0L
 
-        // Try each strategy's validation
-        for (strategy in strategies) {
+        // Try each signature-based strategy first.
+        for (strategy in signatureStrategies) {
             if (strategy.isValid(filePath)) {
                 Log.d(TAG, "Using strategy for $fileName")
                 return strategy.decompress(filePath, destinationPath, progressCallback)
             }
         }
 
-        // No valid strategy found - provide detailed error message
-        val errorMessage =
-            """
-            Failed to decompress file: $fileName ($fileSize bytes)
+        Log.d(TAG, "No ZIP/TAR.GZ signature matched for $fileName, trying TAR.BR fallback")
 
-            Tried strategies: ZIP (magic bytes 0x504B0304), TAR.GZ (magic bytes 0x1F8B), TAR.BR (file extension)
-
-            Supported formats:
-            - ZIP archives (.zip)
-            - GZIP compressed TAR archives (.tar.gz)
-            - Brotli compressed TAR archives (.tar.br)
-
-            Please verify the file is not corrupted and matches one of the supported formats.
-            """.trimIndent()
+        if (tarBrStrategy.decompress(filePath, destinationPath, progressCallback)) {
+            Log.d(TAG, "Using TAR.BR fallback for $fileName")
+            return true
+        }
 
+        val errorMessage = createInvalidArchiveMessage(fileName, fileSize)
         Log.e(TAG, errorMessage)
         return false
     }
 
     /**
-     * Validates if a file is a valid compressed archive.
+     * Validates if a file matches one of the signature-based archive formats.
      * @param filePath Path to the file to validate
      * @return true if the file is a valid compressed archive
      */
     fun isValidZipFile(filePath: String): Boolean {
-        for (strategy in strategies) {
+        for (strategy in signatureStrategies) {
             if (strategy.isValid(filePath)) {
                 return true
             }
         }
-        Log.d(TAG, "No valid strategy found for file: $filePath")
+        Log.d(TAG, "No ZIP/TAR.GZ signature matched for file: $filePath. TAR.BR is handled during extraction fallback.")
         return false
     }
+
+    private fun createInvalidArchiveMessage(
+        fileName: String,
+        fileSize: Long,
+    ): String =
+        """
+        The downloaded bundle file is not a valid compressed archive: $fileName ($fileSize bytes)
+
+        Supported formats:
+        - ZIP archives (.zip)
+        - GZIP compressed TAR archives (.tar.gz)
+        - Brotli compressed TAR archives (.tar.br)
+        """.trimIndent()
 }

package/android/src/main/java/com/hotupdater/HotUpdaterException.kt

@@ -48,7 +48,7 @@ class HotUpdaterException(
         fun extractionFormatError(cause: Throwable? = null) =
             HotUpdaterException(
                 "EXTRACTION_FORMAT_ERROR",
-                "Invalid or corrupted bundle archive format",
+                "The downloaded bundle file is not a valid compressed archive",
                 cause,
             )
 

package/android/src/main/java/com/hotupdater/HotUpdaterImpl.kt

@@ -15,6 +15,8 @@ class HotUpdaterImpl {
     private val context: Context
     private val bundleStorage: BundleStorageService
     private val preferences: PreferencesService
+    private val recoveryManager: HotUpdaterRecoveryManager
+    private var currentLaunchSelection: LaunchSelection? = null
 
     /**
      * Primary constructor with dependency injection (for testing)
@@ -27,6 +29,7 @@ class HotUpdaterImpl {
         this.context = context.applicationContext
         this.bundleStorage = bundleStorage
         this.preferences = preferences
+        this.recoveryManager = HotUpdaterRecoveryManager(this.context)
     }
 
     /**
@@ -265,7 +268,7 @@ class HotUpdaterImpl {
      * Gets the path to the bundle file
      * @return The path to the bundle file
      */
-    fun getJSBundleFile(): String = bundleStorage.getBundleURL()
+    fun getJSBundleFile(): String = prepareLaunchIfNeeded().bundleUrl
 
     /**
      * Updates the bundle from the specified URL
@@ -299,6 +302,7 @@ class HotUpdaterImpl {
      */
     suspend fun reload(reactContext: Context) {
         try {
+            currentLaunchSelection = null
             withContext(Dispatchers.Main) {
                 performReactReload(reactContext)
             }
@@ -309,6 +313,7 @@ class HotUpdaterImpl {
 
     suspend fun reloadProcess(reactContext: Context) {
         try {
+            currentLaunchSelection = null
             withContext(Dispatchers.Main) {
                 if (!restartApplication(reactContext)) {
                     Log.w(TAG, "Falling back to in-process reload because process restart could not be started")
@@ -330,22 +335,24 @@ class HotUpdaterImpl {
 
     // Use a cold restart in release builds so bundle application does not depend on RN reload timing.
     private fun restartApplication(reactContext: Context): Boolean {
+        val applicationContext = reactContext.applicationContext
         val currentActivity =
             (reactContext as? com.facebook.react.bridge.ReactApplicationContext)?.currentActivity
-        if (currentActivity == null) {
-            Log.w(TAG, "Cannot restart app: current activity unavailable")
-            return false
-        }
 
         return try {
             val restartIntent =
-                Intent(currentActivity, HotUpdaterRestartActivity::class.java).apply {
+                Intent(applicationContext, HotUpdaterRestartActivity::class.java).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                     addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
-                    putExtra(HotUpdaterRestartActivity.EXTRA_PACKAGE_NAME, currentActivity.packageName)
+                    putExtra(HotUpdaterRestartActivity.EXTRA_PACKAGE_NAME, applicationContext.packageName)
                     putExtra(HotUpdaterRestartActivity.EXTRA_TARGET_PID, Process.myPid())
                 }
-            val options = ActivityOptions.makeCustomAnimation(currentActivity, 0, 0)
-            currentActivity.startActivity(restartIntent, options.toBundle())
+            if (currentActivity != null) {
+                val options = ActivityOptions.makeCustomAnimation(currentActivity, 0, 0)
+                currentActivity.startActivity(restartIntent, options.toBundle())
+            } else {
+                applicationContext.startActivity(restartIntent)
+            }
 
             Log.i(TAG, "Started restart trampoline to apply update bundle")
             return true
@@ -356,12 +363,11 @@ class HotUpdaterImpl {
     }
 
     /**
-     * Notifies the system that the app has successfully started with the given bundle.
-     * If the bundle matches the staging bundle, it promotes to stable.
-     * @param bundleId The ID of the currently running bundle
+     * Returns the launch report for the current process.
+     * Startup success and rollback are finalized before JS reads it.
      * @return Map containing status and optional crashedBundleId
      */
-    fun notifyAppReady(bundleId: String): Map<String, Any?> = bundleStorage.notifyAppReady(bundleId)
+    fun notifyAppReady(): Map<String, Any?> = bundleStorage.notifyAppReady()
 
     /**
      * Gets the crashed bundle history.
@@ -383,11 +389,43 @@ class HotUpdaterImpl {
      */
     fun getBaseURL(): String = bundleStorage.getBaseURL()
 
+    /**
+     * Gets the current active bundle ID from bundle storage.
+     * Reads manifest.json first and falls back to the legacy BUNDLE_ID file.
+     * Built-in bundle fallback is handled in JS.
+     */
+    fun getBundleId(): String? = bundleStorage.getBundleId()
+
+    /**
+     * Gets the current manifest from bundle storage.
+     */
+    fun getManifest(): Map<String, Any?> = bundleStorage.getManifest()
+
     suspend fun resetChannel(): Boolean {
         val success = bundleStorage.resetChannel()
         if (success) {
             preferences.setItem(CHANNEL_STORAGE_KEY, null)
+            currentLaunchSelection = null
         }
         return success
     }
+
+    private fun prepareLaunchIfNeeded(): LaunchSelection {
+        currentLaunchSelection?.let { return it }
+
+        val pendingRecovery = recoveryManager.consumePendingCrashRecovery()
+        val selection = bundleStorage.prepareLaunch(pendingRecovery)
+        recoveryManager.startMonitoring(
+            bundleId = selection.launchedBundleId,
+            shouldRollback = selection.shouldRollbackOnCrash,
+            onContentAppeared = { launchedBundleId ->
+                bundleStorage.markLaunchCompleted(launchedBundleId)
+            },
+            onRecoveryRestartRequested = {
+                restartApplication(context)
+            },
+        )
+        currentLaunchSelection = selection
+        return selection
+    }
 }