@hot-updater/react-native 1.0.0-rc.33 → 1.0.0-rc.35

package/android/build.gradle

@@ -20,8 +20,12 @@ def reactNativeArchitectures() {
   return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
+// The New Architecture is the default. React Native 0.82 and later run nothing
+// else and set newArchEnabled to true on every library project, whatever the
+// app's gradle.properties says, so only an older React Native app that sets
+// newArchEnabled=false builds the old architecture.
 def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+  return !project.hasProperty("newArchEnabled") || project.property("newArchEnabled").toString().toBoolean()
 }
 
 apply plugin: "com.android.library"
@@ -115,7 +119,11 @@ android {
           "src/newarch",
           // Codegen specs
           "generated/java",
-          "generated/jni"
+          "generated/jni",
+          // React Native 0.81 and older can run the New Architecture on the
+          // bridge. Later versions have none, so their builds never compile
+          // ReactNativeHost.
+          project.ext.reactNativeMinorVersion >= 82 ? "src/bridgeless" : "src/bridge"
         ]
       }
     }
@@ -146,6 +154,9 @@ dependencies {
   }
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.1"
+  // ProcessLifecycleOwner, for an activity that started before Hot Updater was created.
+  // React Native's AppCompat already brings it at runtime.
+  implementation "androidx.lifecycle:lifecycle-process:2.6.1"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
   implementation "org.apache.commons:commons-compress:1.27.1"

package/android/proguard-rules.pro

@@ -6,15 +6,6 @@
 }
 
 # New Architecture
-# Crash recovery discovers these accessors through reflection.
--keepclassmembers class * implements com.facebook.react.ReactApplication {
-    public *** getReactHost();
-}
-
--keepclassmembers class * implements com.facebook.react.ReactHost {
-    public *** getCurrentReactContext();
-}
-
 # Keep fields accessed via reflection in ReactHost
 # Support both Java (mReactHostDelegate) and Kotlin (reactHostDelegate) field names
 -keepclassmembers class com.facebook.react.runtime.ReactHostImpl {

package/android/src/bridge/BridgeReactInstance.kt

@@ -0,0 +1,38 @@
+package com.hotupdater
+
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+/**
+ * React Native 0.81 and older can run the New Architecture on the bridge, which
+ * only ReactNativeHost reaches. Only builds for those versions compile this file.
+ */
+internal object BridgeReactInstance {
+    fun setJSBundle(
+        application: ReactApplication,
+        bundleLoader: JSBundleLoader?,
+    ) {
+        @Suppress("DEPRECATION")
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val bundleLoaderField = instanceManager::class.java.getDeclaredField("mBundleLoader")
+        bundleLoaderField.isAccessible = true
+        bundleLoaderField.set(instanceManager, bundleLoader)
+    }
+
+    fun reload(application: ReactApplication) {
+        @Suppress("DEPRECATION")
+        val reactNativeHost = application.reactNativeHost
+        try {
+            reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+        } catch (e: Exception) {
+            val currentActivity = reactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
+            if (currentActivity == null) {
+                return
+            }
+
+            currentActivity.runOnUiThread {
+                currentActivity.recreate()
+            }
+        }
+    }
+}

package/android/src/bridgeless/BridgeReactInstance.kt

@@ -0,0 +1,24 @@
+package com.hotupdater
+
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+/**
+ * React Native 0.82 and later have no bridge, so an app without a ReactHost has
+ * no instance to update. Builds for those versions compile this file instead of
+ * the bridge one, and never reference ReactNativeHost.
+ */
+@Suppress("UNUSED_PARAMETER")
+internal object BridgeReactInstance {
+    fun setJSBundle(
+        application: ReactApplication,
+        bundleLoader: JSBundleLoader?,
+    ) {
+        Log.d("HotUpdater", "No ReactHost to set the JS bundle on")
+    }
+
+    fun reload(application: ReactApplication) {
+        Log.d("HotUpdater", "No ReactHost to reload")
+    }
+}

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

@@ -0,0 +1,94 @@
+package com.hotupdater
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.ProcessLifecycleOwner
+
+/**
+ * Runs an action once this process has a started activity.
+ *
+ * A headless JS task (HeadlessJsTaskService, which background push libraries
+ * start) loads the bundle with no activity and never renders. Waiting for an
+ * activity keeps that launch from counting as one that ended before its first
+ * render.
+ *
+ * Android does not replay lifecycle callbacks to a late registration. An
+ * activity that started before this gate existed, as when a brownfield app adds
+ * React Native to an activity already on screen, is read from
+ * [processHasStartedActivity] instead.
+ */
+internal class ActivityStartGate(
+    private val application: Application?,
+    private val processHasStartedActivity: () -> Boolean = ::hasStartedActivity,
+) : Application.ActivityLifecycleCallbacks {
+    private var startedActivities = 0
+    private var pendingAction: (() -> Unit)? = null
+
+    init {
+        application?.registerActivityLifecycleCallbacks(this)
+    }
+
+    /**
+     * Runs [action] now when an activity is started, otherwise at the next
+     * activity start. It replaces an action still waiting; null cancels it.
+     * Without an application to observe, it runs [action] now.
+     */
+    fun runWhenActivityStarted(action: (() -> Unit)?) {
+        val runNow =
+            synchronized(this) {
+                val waits =
+                    application != null &&
+                        startedActivities == 0 &&
+                        !processHasStartedActivity()
+                pendingAction = action.takeIf { waits }
+                action.takeUnless { waits }
+            }
+        runNow?.invoke()
+    }
+
+    override fun onActivityStarted(activity: Activity) {
+        val action =
+            synchronized(this) {
+                startedActivities += 1
+                pendingAction.also { pendingAction = null }
+            }
+        action?.invoke()
+    }
+
+    override fun onActivityStopped(activity: Activity) {
+        synchronized(this) {
+            // An activity started before this gate existed was never counted.
+            if (startedActivities > 0) startedActivities -= 1
+        }
+    }
+
+    override fun onActivityCreated(
+        activity: Activity,
+        savedInstanceState: Bundle?,
+    ) {}
+
+    override fun onActivityResumed(activity: Activity) {}
+
+    override fun onActivityPaused(activity: Activity) {}
+
+    override fun onActivitySaveInstanceState(
+        activity: Activity,
+        outState: Bundle,
+    ) {}
+
+    override fun onActivityDestroyed(activity: Activity) {}
+}
+
+// ProcessLifecycleOwner observes activities from process start, through the
+// androidx.startup initializer that lifecycle-process registers. It is STARTED
+// while an activity of this process is started, and stays at INITIALIZED when
+// an app removes that initializer, so the gate then waits for the next start.
+private fun hasStartedActivity(): Boolean =
+    runCatching {
+        ProcessLifecycleOwner
+            .get()
+            .lifecycle.currentState
+            .isAtLeast(Lifecycle.State.STARTED)
+    }.getOrDefault(false)

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

@@ -151,6 +151,12 @@ interface BundleStorageService {
 
     suspend fun commitReleaseSelection(selection: PersistedSelection): Boolean = false
 
+    /**
+     * Records that the current launch of a verification-pending bundle can show UI.
+     * The next process rolls the bundle back unless first content verified it.
+     */
+    fun markLaunchStarted(launchedBundleId: String?)
+
     /**
      * Marks the current launch as successful after the first content appeared.
      */
@@ -162,7 +168,8 @@ interface BundleStorageService {
     fun notifyAppReady(): Map<String, Any?>
 
     /**
-     * Gets the crashed bundle history
+     * Gets the crashed bundle history, plus a bundle that waits for its retry after
+     * an unfinished launch while this process still refuses it (see [InterruptedLaunch])
      * @return CrashedHistory containing crashed bundles
      */
     fun getCrashHistory(): CrashedHistory
@@ -592,6 +599,16 @@ class BundleFileStorageService(
     private var hasPreparedLaunch = false
     private var currentLaunchReport: LaunchReport? = null
 
+    // The staged bundle this process launched before its first content. Only that
+    // launch is pending; a bundle staged later waits for the next launch.
+    private var pendingLaunchBundleId: String? = null
+
+    // Crash history is written at first content on the main thread while JS can read it.
+    private val crashedHistoryLock = Any()
+
+    // A bundle waiting for its retry that this process keeps refusing, see InterruptedLaunch.
+    private var retryHeldBundleId: String? = null
+
     @Volatile
     private var activeBundleMetadataSnapshot: ActiveBundleMetadataSnapshot? = null
     private val activeBundleMetadataLock = Any()
@@ -1092,7 +1109,14 @@ class BundleFileStorageService(
         )
     }
 
-    private fun rollbackPendingBundle(stagingBundleId: String): Boolean {
+    /**
+     * Rolls back the pending staging bundle. [unfinishedLaunch] means its launch
+     * ended before first content without a crash marker.
+     */
+    private fun rollbackPendingBundle(
+        stagingBundleId: String,
+        unfinishedLaunch: Boolean = false,
+    ): Boolean {
         val metadata = loadMetadataOrNull() ?: return false
         if (metadata.stagingBundleId != stagingBundleId) {
             return false
@@ -1100,9 +1124,7 @@ class BundleFileStorageService(
 
         Log.w(TAG, "Rolling back crashed staging bundle: $stagingBundleId")
 
-        val crashedHistory = loadCrashedHistory()
-        crashedHistory.addEntry(stagingBundleId)
-        saveCrashedHistory(crashedHistory)
+        recordFailedLaunch(stagingBundleId, unfinishedLaunch)
 
         val fallbackBundleId =
             metadata.stableBundleId?.takeIf { candidate ->
@@ -1369,18 +1391,98 @@ class BundleFileStorageService(
 
     private fun saveCrashedHistory(history: CrashedHistory): Boolean = history.saveToFile(getCrashedHistoryFile())
 
-    private fun isBundleInCrashedHistory(bundleId: String): Boolean = loadCrashedHistory().contains(bundleId)
+    private fun isBundleInCrashedHistory(bundleId: String): Boolean = getCrashHistory().contains(bundleId)
 
-    override fun getCrashHistory(): CrashedHistory = loadCrashedHistory()
+    /**
+     * The bundles this device refuses to install: crash history, plus a bundle
+     * waiting for its retry until a process that may retry it.
+     */
+    override fun getCrashHistory(): CrashedHistory =
+        synchronized(crashedHistoryLock) {
+            val history = loadCrashedHistory()
+            val interrupted = history.interruptedLaunch
+            if (interrupted != null &&
+                (!interrupted.retryReady || interrupted.bundleId == retryHeldBundleId) &&
+                !history.contains(interrupted.bundleId)
+            ) {
+                history.bundles.add(CrashedBundleEntry(interrupted.bundleId, crashedAt = System.currentTimeMillis()))
+            }
+            history
+        }
 
     override fun clearCrashHistory(): Boolean {
-        val history = CrashedHistory()
-        saveCrashedHistory(history)
+        synchronized(crashedHistoryLock) {
+            saveCrashedHistory(CrashedHistory())
+            retryHeldBundleId = null
+        }
         Log.d(TAG, "Cleared crash history")
         return true
     }
 
+    /**
+     * A crash, or a second unfinished launch of the same bundle, adds the bundle to
+     * crash history. A first unfinished launch cannot tell a hang from a user leaving
+     * early, so it leaves the bundle one retry instead.
+     */
+    private fun recordFailedLaunch(
+        bundleId: String,
+        unfinishedLaunch: Boolean,
+    ) {
+        synchronized(crashedHistoryLock) {
+            val history = loadCrashedHistory()
+            val interrupted = history.interruptedLaunch
+            if (unfinishedLaunch && interrupted?.bundleId != bundleId) {
+                Log.w(TAG, "Launch of $bundleId ended before first content; it gets one retry")
+                history.interruptedLaunch = InterruptedLaunch(bundleId)
+                retryHeldBundleId = bundleId
+            } else {
+                history.addEntry(bundleId)
+                if (interrupted?.bundleId == bundleId) {
+                    history.interruptedLaunch = null
+                }
+            }
+            saveCrashedHistory(history)
+        }
+    }
+
+    /**
+     * First content appeared, so the app works again. A bundle waiting for its retry
+     * may be installed from the next process on. This process keeps refusing it, so
+     * the session that recovered never reloads into it. Content from that bundle
+     * verifies it.
+     */
+    private fun readyInterruptedLaunchRetry(currentBundleId: String?) {
+        synchronized(crashedHistoryLock) {
+            val history = loadCrashedHistory()
+            val interrupted = history.interruptedLaunch ?: return
+            if (interrupted.bundleId == currentBundleId) {
+                history.interruptedLaunch = null
+            } else if (interrupted.retryReady) {
+                return
+            } else {
+                history.interruptedLaunch = interrupted.copy(retryReady = true)
+                retryHeldBundleId = interrupted.bundleId
+            }
+            saveCrashedHistory(history)
+        }
+    }
+
+    override fun markLaunchStarted(launchedBundleId: String?) {
+        // Unlike prepareLaunch, this can run while JS stages a newer bundle.
+        synchronized(releaseStateLock) {
+            val metadata = loadMetadataOrNull() ?: return
+            if (!isVerificationPending(metadata) ||
+                metadata.launchInProgress ||
+                metadata.stagingBundleId != launchedBundleId
+            ) {
+                return
+            }
+            saveMetadata(metadata.copy(launchInProgress = true))
+        }
+    }
+
     override fun markLaunchCompleted(currentBundleId: String?) {
+        readyInterruptedLaunchRetry(currentBundleId)
         val metadata = loadMetadataOrNull() ?: return
         val stagingBundleId = metadata.stagingBundleId ?: return
         if (!metadata.verificationPending || stagingBundleId != currentBundleId) {
@@ -1418,7 +1520,11 @@ class BundleFileStorageService(
         val report = loadLaunchReport()
         if (report == null) {
             val metadata = loadMetadataOrNull()
-            if (metadata?.verificationPending == true && metadata.stagingBundleId != null) {
+            val launchedBundleId = pendingLaunchBundleId
+            if (launchedBundleId != null &&
+                metadata?.verificationPending == true &&
+                metadata.stagingBundleId == launchedBundleId
+            ) {
                 return mapOf("status" to "PENDING")
             }
             return mapOf("status" to "UNCHANGED")
@@ -1483,17 +1589,14 @@ class BundleFileStorageService(
         if (!hasPreparedLaunch) {
             val metadata = loadMetadataOrNull()
             if (metadata?.verificationPending == true && metadata.launchInProgress) {
-                metadata.stagingBundleId?.let { rollbackPendingBundle(it) }
+                metadata.stagingBundleId?.let { rollbackPendingBundle(it, unfinishedLaunch = true) }
             }
         }
         hasPreparedLaunch = true
 
+        // A launch is recorded only once it can show UI (markLaunchStarted).
         val selection = selectLaunch()
-        if (selection.shouldRollbackOnCrash) {
-            loadMetadataOrNull()?.let { metadata ->
-                saveMetadata(metadata.copy(launchInProgress = true))
-            }
-        }
+        pendingLaunchBundleId = selection.launchedBundleId.takeIf { selection.shouldRollbackOnCrash }
         Log.d(
             TAG,
             "prepareLaunch: bundleId=${selection.launchedBundleId} shouldRollback=${selection.shouldRollbackOnCrash} url=${selection.bundleUrl}",

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

@@ -296,12 +296,44 @@ data class CrashedBundleEntry(
         }
 }
 
+/**
+ * A bundle whose launch ended before first content without a crash, waiting
+ * for its one retry. Such a launch cannot tell a hang from a user leaving
+ * early, so the bundle is offered again instead of entering crash history.
+ * A second unfinished launch of it adds it there.
+ *
+ * [retryReady] turns true once a later launch shows content. The retry
+ * starts with the next process, so the session that recovered never reloads
+ * into the same bundle.
+ */
+data class InterruptedLaunch(
+    val bundleId: String,
+    val retryReady: Boolean = false,
+) {
+    companion object {
+        fun fromJson(json: JSONObject): InterruptedLaunch? =
+            json.optNullableString("bundleId")?.let { bundleId ->
+                InterruptedLaunch(
+                    bundleId = bundleId,
+                    retryReady = json.optBoolean("retryReady", false),
+                )
+            }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("bundleId", bundleId)
+            put("retryReady", retryReady)
+        }
+}
+
 /**
  * History of crashed bundles
  */
 data class CrashedHistory(
     val bundles: MutableList<CrashedBundleEntry> = mutableListOf(),
     val maxHistorySize: Int = DEFAULT_MAX_HISTORY_SIZE,
+    var interruptedLaunch: InterruptedLaunch? = null,
 ) {
     companion object {
         private const val TAG = "CrashedHistory"
@@ -317,6 +349,7 @@ data class CrashedHistory(
             return CrashedHistory(
                 bundles = bundles,
                 maxHistorySize = json.optInt("maxHistorySize", DEFAULT_MAX_HISTORY_SIZE),
+                interruptedLaunch = json.optJSONObject("interruptedLaunch")?.let(InterruptedLaunch::fromJson),
             )
         }
 
@@ -342,6 +375,7 @@ data class CrashedHistory(
             bundles.forEach { bundlesArray.put(it.toJson()) }
             put("bundles", bundlesArray)
             put("maxHistorySize", maxHistorySize)
+            interruptedLaunch?.let { put("interruptedLaunch", it.toJson()) }
         }
 
     fun saveToFile(file: File): Boolean =
@@ -389,6 +423,7 @@ data class CrashedHistory(
 
     fun clear() {
         bundles.clear()
+        interruptedLaunch = null
     }
 }
 

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

@@ -1,6 +1,7 @@
 package com.hotupdater
 
 import android.app.ActivityOptions
+import android.app.Application
 import android.content.Context
 import android.content.Intent
 import android.os.Process
@@ -20,6 +21,7 @@ class HotUpdaterImpl {
     private val releaseCatalogCache: ReleaseCatalogCacheService
     private val installIdentity: InstallIdentityService
     private val keyValueStorage: KeyValueStorageService
+    private val activityStartGate: ActivityStartGate
     private var currentLaunchSelection: LaunchSelection? = null
 
     /**
@@ -33,6 +35,7 @@ class HotUpdaterImpl {
         this.context = context.applicationContext
         this.bundleStorage = bundleStorage
         this.preferences = preferences
+        this.activityStartGate = ActivityStartGate(this.context as? Application)
         this.recoveryManager = HotUpdaterRecoveryManager(this.context)
         this.releaseCatalogCache =
             ReleaseCatalogCacheService(
@@ -40,7 +43,6 @@ class HotUpdaterImpl {
             )
         this.installIdentity = InstallIdentityService.create(this.context)
         this.keyValueStorage = KeyValueStorageService.create(this.context)
-        PreviousProcessExit.initialize(this.context)
     }
 
     /**
@@ -379,15 +381,7 @@ class HotUpdaterImpl {
         }
     }
 
-    /**
-     * The launch report for this process, with `previousProcessExit` when
-     * Android reports why the previous main process exited.
-     */
-    fun notifyAppReady(): Map<String, Any?> {
-        val report = bundleStorage.notifyAppReady()
-        val previousProcessExit = PreviousProcessExit.get() ?: return report
-        return report + ("previousProcessExit" to previousProcessExit)
-    }
+    fun notifyAppReady(): Map<String, Any?> = bundleStorage.notifyAppReady()
 
     fun acceptReleaseCatalog(
         catalogId: String,
@@ -517,6 +511,16 @@ class HotUpdaterImpl {
 
         val pendingRecovery = recoveryManager.consumePendingCrashRecovery()
         val selection = bundleStorage.prepareLaunch(pendingRecovery)
+        // A headless JS task, such as a background push, loads the bundle without
+        // an activity and never renders. Only a launch with an activity may leave
+        // an unfinished launch for the next process to roll back.
+        activityStartGate.runWhenActivityStarted(
+            if (selection.shouldRollbackOnCrash) {
+                { bundleStorage.markLaunchStarted(selection.launchedBundleId) }
+            } else {
+                null
+            },
+        )
         recoveryManager.startMonitoring(
             bundleId = selection.launchedBundleId,
             shouldRollback = selection.shouldRollbackOnCrash,