@hot-updater/react-native 1.0.0-rc.1 → 1.0.0-rc.15

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

@@ -21,6 +21,7 @@ data class BundleMetadata(
     val pendingUpdateStrategy: String? = null,
     val pendingTransition: PendingSelectionTransition? = null,
     val verificationPending: Boolean = false,
+    val launchInProgress: Boolean = false,
     val highestSeenCatalogs: Map<String, CatalogHighWater> = emptyMap(),
     val currentSelectionContexts: Map<String, String> = emptyMap(),
     val updatedAt: Long = System.currentTimeMillis(),
@@ -71,6 +72,7 @@ data class BundleMetadata(
                 pendingTransition =
                     json.optJSONObject("pendingTransition")?.let(PendingSelectionTransition::fromJson),
                 verificationPending = json.optBoolean("verificationPending", false),
+                launchInProgress = json.optBoolean("launchInProgress", false),
                 highestSeenCatalogs = highestSeenCatalogs,
                 currentSelectionContexts = currentSelectionContexts,
                 updatedAt = json.optLong("updatedAt", System.currentTimeMillis()),
@@ -121,6 +123,7 @@ data class BundleMetadata(
             put("pendingUpdateStrategy", pendingUpdateStrategy ?: JSONObject.NULL)
             put("pendingTransition", pendingTransition?.toJson() ?: JSONObject.NULL)
             put("verificationPending", verificationPending)
+            put("launchInProgress", launchInProgress)
             put(
                 "highestSeenCatalogs",
                 JSONObject().apply {
@@ -394,6 +397,13 @@ data class PendingCrashRecovery(
     val shouldRollback: Boolean,
 ) {
     companion object {
+        internal fun loadFromFile(file: File): PendingCrashRecovery? =
+            try {
+                fromJson(JSONObject(file.readText()))
+            } catch (_: Exception) {
+                null
+            }
+
         fun fromJson(json: JSONObject): PendingCrashRecovery =
             PendingCrashRecovery(
                 launchedBundleId =

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

@@ -17,12 +17,6 @@ class HotUpdaterException(
                 "Missing or empty 'bundleId'",
             )
 
-        fun invalidFileUrl() =
-            HotUpdaterException(
-                "INVALID_FILE_URL",
-                "Invalid 'fileUrl' provided",
-            )
-
         // Bundle storage errors
         fun directoryCreationFailed() =
             HotUpdaterException(
@@ -45,13 +39,6 @@ class HotUpdaterException(
             "Download incomplete: received $actualSize bytes, expected $expectedSize bytes",
         )
 
-        fun extractionFormatError(cause: Throwable? = null) =
-            HotUpdaterException(
-                "EXTRACTION_FORMAT_ERROR",
-                "The downloaded bundle file is not a valid compressed archive",
-                cause,
-            )
-
         fun invalidBundle() =
             HotUpdaterException(
                 "INVALID_BUNDLE",

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

@@ -83,14 +83,12 @@ class HotUpdaterImpl {
             val fileSystem = FileManagerService(appContext)
             val preferences = createPreferences(appContext)
             val downloadService = OkHttpDownloadService()
-            val decompressService = DecompressService()
             val isolationKey = getIsolationKey(appContext)
 
             return BundleFileStorageService(
                 appContext,
                 fileSystem,
                 downloadService,
-                decompressService,
                 preferences,
                 isolationKey,
             )
@@ -268,22 +266,22 @@ class HotUpdaterImpl {
     fun getJSBundleFile(): String = prepareLaunchIfNeeded().bundleUrl
 
     /**
-     * Updates the bundle from the specified URL
+     * Updates the bundle from its manifest and complete asset descriptors.
      * @param bundleId ID of the bundle to update
-     * @param fileUrl URL of the bundle file to download (or null to reset)
-     * @param fileHash Combined hash string for verification (sig:<signature> or <hex_hash>)
+     * @param manifestUrl URL of the target manifest
+     * @param manifestFileHash Hash or signature used to verify the target manifest
+     * @param assets Complete target asset descriptor map
      * @param progressCallback Callback for download progress updates
      * @throws HotUpdaterException if the update fails
      */
     suspend fun updateBundle(
         bundleId: String,
-        fileUrl: String?,
-        fileHash: String?,
-        manifestUrl: String?,
-        manifestFileHash: String?,
-        changedAssets: Map<String, ChangedAssetDescriptor>?,
+        manifestUrl: String,
+        manifestFileHash: String,
+        assets: Map<String, ChangedAssetDescriptor>,
         channel: String?,
         selection: PersistedSelection? = null,
+        archiveUrl: String? = null,
         progressCallback: (UpdateProgressPayload) -> Unit,
     ) {
         if (selection != null && !bundleStorage.stageReleaseSelection(selection)) {
@@ -291,11 +289,10 @@ class HotUpdaterImpl {
         }
         bundleStorage.updateBundle(
             bundleId,
-            fileUrl,
-            fileHash,
             manifestUrl,
             manifestFileHash,
-            changedAssets,
+            assets,
+            archiveUrl,
             progressCallback,
         )
 
@@ -467,7 +464,6 @@ class HotUpdaterImpl {
 
     /**
      * Gets the current launched bundle ID.
-     * Reads manifest.json first and falls back to the legacy BUNDLE_ID file.
      * Built-in bundle fallback is handled in JS.
      */
     fun getBundleId(): String? {

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

@@ -9,6 +9,7 @@ import android.os.Looper
 import android.os.Process
 import android.os.SystemClock
 import android.util.Log
+import androidx.core.util.AtomicFile
 import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.JSExceptionHandler
 import com.facebook.react.bridge.ReactContext
@@ -16,6 +17,7 @@ import com.facebook.react.bridge.ReactMarker
 import com.facebook.react.bridge.ReactMarkerConstants
 import org.json.JSONObject
 import java.io.File
+import java.io.FileOutputStream
 import java.lang.reflect.Field
 import kotlin.system.exitProcess
 
@@ -28,10 +30,7 @@ internal class HotUpdaterRecoveryManager(
     private val crashMarkerFile = File(bundleStoreDir, CRASH_MARKER_FILENAME)
     private val watchdogStateFile = File(bundleStoreDir, WATCHDOG_STATE_FILENAME)
 
-    private var currentBundleId: String? = null
-    private var shouldRollbackOnCrash = false
-    private var isMonitoring = false
-    private var recoveryRequested = false
+    private val launchState = HotUpdaterRecoveryState()
     private var contentAppearedCallback: ((String?) -> Unit)? = null
     private var recoveryRestartCallback: (() -> Boolean)? = null
 
@@ -39,10 +38,7 @@ internal class HotUpdaterRecoveryManager(
         Runnable {
             cancelRecoveryWatchdog()
             Log.d(TAG, "Stopping crash monitoring for current launch")
-            isMonitoring = false
-            recoveryRequested = false
-            shouldRollbackOnCrash = false
-            currentBundleId = null
+            launchState.stop()
             contentAppearedCallback = null
             recoveryRestartCallback = null
             activeManager = null
@@ -52,7 +48,7 @@ internal class HotUpdaterRecoveryManager(
     private val installJsExceptionHooksRunnable =
         object : Runnable {
             override fun run() {
-                if (!isMonitoring) {
+                if (launchState.snapshot() == null) {
                     return
                 }
 
@@ -74,7 +70,7 @@ internal class HotUpdaterRecoveryManager(
         }
 
         return try {
-            val recovery = PendingCrashRecovery.fromJson(JSONObject(crashMarkerFile.readText()))
+            val recovery = PendingCrashRecovery.loadFromFile(crashMarkerFile) ?: return null
             Log.d(
                 TAG,
                 "Consumed pending crash marker bundleId=${recovery.launchedBundleId} shouldRollback=${recovery.shouldRollback}",
@@ -96,11 +92,8 @@ internal class HotUpdaterRecoveryManager(
     ) {
         crashMarkerFile.parentFile?.mkdirs()
         contentAppearedCallback = onContentAppeared
-        currentBundleId = bundleId
-        shouldRollbackOnCrash = shouldRollback
-        isMonitoring = true
-        recoveryRequested = false
         recoveryRestartCallback = onRecoveryRestartRequested
+        launchState.start(bundleId, shouldRollback)
         activeManager = this
 
         ensureExceptionHandlerInstalled()
@@ -122,17 +115,13 @@ internal class HotUpdaterRecoveryManager(
     }
 
     private fun handleContentAppeared() {
-        if (!isMonitoring) {
-            return
-        }
-
-        Log.d(TAG, "First content appeared for bundleId=$currentBundleId")
+        val launch = launchState.completeLaunch() ?: return
+        Log.d(TAG, "First content appeared for bundleId=${launch.bundleId}")
         ReactMarker.removeListener(contentAppearedListener)
         mainHandler.removeCallbacks(installJsExceptionHooksRunnable)
         mainHandler.removeCallbacks(stopMonitoringRunnable)
-        contentAppearedCallback?.invoke(currentBundleId)
-        shouldRollbackOnCrash = false
-        updateNativeLaunchState(currentBundleId, false)
+        contentAppearedCallback?.invoke(launch.bundleId)
+        updateNativeLaunchState(launch.bundleId, false)
         cancelRecoveryWatchdog()
         mainHandler.postDelayed(stopMonitoringRunnable, MONITORING_GRACE_PERIOD_MS)
     }
@@ -145,11 +134,10 @@ internal class HotUpdaterRecoveryManager(
         previousExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
         Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
             val manager = activeManager
-            manager?.writeCrashMarker()
-
             if (manager?.requestAutomaticRecovery() == true) {
-                Process.killProcess(Process.myPid())
-                exitProcess(10)
+                // The separate restart activity kills this process after it starts.
+                // A second fatal error must not kill it while that request is in flight.
+                return@setDefaultUncaughtExceptionHandler
             }
 
             previousExceptionHandler?.uncaughtException(thread, throwable)
@@ -161,20 +149,21 @@ internal class HotUpdaterRecoveryManager(
         exceptionHandlerInstalled = true
     }
 
-    private fun writeCrashMarker() {
-        if (!isMonitoring) {
-            return
-        }
-
+    private fun writeCrashMarker(launch: HotUpdaterRecoveryState.Launch) {
+        val atomicFile = AtomicFile(crashMarkerFile)
+        var output: FileOutputStream? = null
         try {
             val payload =
                 JSONObject().apply {
-                    put("bundleId", currentBundleId ?: JSONObject.NULL)
-                    put("shouldRollback", shouldRollbackOnCrash)
+                    put("bundleId", launch.bundleId ?: JSONObject.NULL)
+                    put("shouldRollback", launch.shouldRollback)
                 }
             crashMarkerFile.parentFile?.mkdirs()
-            crashMarkerFile.writeText(payload.toString())
+            output = atomicFile.startWrite()
+            output.write(payload.toString().toByteArray(Charsets.UTF_8))
+            atomicFile.finishWrite(output)
         } catch (e: Exception) {
+            output?.let(atomicFile::failWrite)
             Log.e(TAG, "Failed to write crash marker", e)
         }
     }
@@ -194,35 +183,28 @@ internal class HotUpdaterRecoveryManager(
         cancelRecoveryWatchdogAlarm(appContext)
     }
 
-    private fun requestAutomaticRecovery(): Boolean {
-        if (!isMonitoring || !shouldRollbackOnCrash) {
-            return false
+    private fun requestAutomaticRecovery(exception: Exception? = null): Boolean {
+        val request = launchState.requestRecovery()
+        if (exception != null) {
+            Log.e(TAG, "Caught React startup exception for bundleId=${launchState.snapshot()?.bundleId}", exception)
         }
-
-        synchronized(this) {
-            if (recoveryRequested) {
-                return true
-            }
-            recoveryRequested = true
+        if (request == null) {
+            launchState.snapshot()?.let(::writeCrashMarker)
+            return false
         }
-
+        if (!request.shouldRestart) return true
+        writeCrashMarker(request.launch)
         val started = recoveryRestartCallback?.invoke() == true
+        launchState.finishRecoveryRequest(request, started)
         if (!started) {
-            synchronized(this) {
-                recoveryRequested = false
-            }
             Log.w(TAG, "Failed to schedule automatic recovery restart")
         } else {
-            Log.i(TAG, "Scheduled automatic recovery restart for bundleId=$currentBundleId")
+            Log.i(TAG, "Scheduled automatic recovery restart for bundleId=${request.launch.bundleId}")
         }
         return started
     }
 
-    private fun handleJavaScriptException(exception: Exception): Boolean {
-        Log.e(TAG, "Caught React startup exception for bundleId=$currentBundleId", exception)
-        writeCrashMarker()
-        return requestAutomaticRecovery()
-    }
+    private fun handleJavaScriptException(exception: Exception): Boolean = requestAutomaticRecovery(exception)
 
     private fun ensureNativeSignalHandlerInstalled() {
         if (signalHandlerInstalled || !loadNativeLibrary()) {
@@ -467,7 +449,8 @@ internal class HotUpdaterRecoveryManager(
             }
 
             val crashMarkerFile = File(getBundleStoreDir(appContext), CRASH_MARKER_FILENAME)
-            if (crashMarkerFile.exists()) {
+            val recovery = PendingCrashRecovery.loadFromFile(crashMarkerFile)
+            if (recovery?.shouldRollback == true && recovery.launchedBundleId != null) {
                 Log.i(TAG, "Recovery watchdog detected crash marker, relaunching app")
                 watchdogStateFile.delete()
                 cancelRecoveryWatchdogAlarm(appContext)

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

@@ -0,0 +1,64 @@
+package com.hotupdater
+
+internal class HotUpdaterRecoveryState {
+    data class Launch(
+        val bundleId: String?,
+        val shouldRollback: Boolean,
+    )
+
+    data class RecoveryRequest(
+        val launch: Launch,
+        val shouldRestart: Boolean,
+    )
+
+    private enum class RestartState { NONE, REQUESTED, SCHEDULED, FAILED }
+
+    private var launch: Launch? = null
+    private var restartState = RestartState.NONE
+    private var contentAppeared = false
+
+    @Synchronized
+    fun start(
+        bundleId: String?,
+        shouldRollback: Boolean,
+    ) {
+        launch = Launch(bundleId, shouldRollback)
+        restartState = RestartState.NONE
+        contentAppeared = false
+    }
+
+    @Synchronized
+    fun snapshot(): Launch? = launch
+
+    @Synchronized
+    fun stop() {
+        launch = null
+        restartState = RestartState.NONE
+    }
+
+    @Synchronized
+    fun completeLaunch(): Launch? {
+        val current = launch ?: return null
+        if (contentAppeared || restartState != RestartState.NONE) return null
+        contentAppeared = true
+        launch = current.copy(shouldRollback = false)
+        return current
+    }
+
+    @Synchronized
+    fun requestRecovery(): RecoveryRequest? {
+        val current = launch?.takeIf { it.shouldRollback } ?: return null
+        val shouldRestart = restartState == RestartState.NONE || restartState == RestartState.FAILED
+        if (shouldRestart) restartState = RestartState.REQUESTED
+        return RecoveryRequest(current, shouldRestart)
+    }
+
+    @Synchronized
+    fun finishRecoveryRequest(
+        request: RecoveryRequest,
+        started: Boolean,
+    ) {
+        if (launch !== request.launch) return
+        restartState = if (started) RestartState.SCHEDULED else RestartState.FAILED
+    }
+}

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

@@ -65,6 +65,13 @@ interface DownloadService {
         fileSizeCallback: ((Long) -> Unit)? = null,
         progressCallback: (DownloadProgress) -> Unit,
     ): DownloadResult
+
+    suspend fun downloadFileOnce(
+        fileUrl: URL,
+        destination: File,
+        fileSizeCallback: ((Long) -> Unit)? = null,
+        progressCallback: (DownloadProgress) -> Unit,
+    ): DownloadResult = downloadFile(fileUrl, destination, fileSizeCallback, progressCallback)
 }
 
 /**
@@ -185,6 +192,18 @@ class OkHttpDownloadService : DownloadService {
             DownloadResult.Error(lastException ?: Exception("Download failed after $MAX_RETRIES attempts"))
         }
 
+    override suspend fun downloadFileOnce(
+        fileUrl: URL,
+        destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
+        progressCallback: (DownloadProgress) -> Unit,
+    ): DownloadResult =
+        try {
+            attemptDownload(fileUrl, destination, fileSizeCallback, progressCallback)
+        } catch (error: Exception) {
+            DownloadResult.Error(error)
+        }
+
     private suspend fun attemptDownload(
         fileUrl: URL,
         destination: File,