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

package/android/proguard-rules.pro

@@ -2,9 +2,19 @@
 # Invoked via reflection, when setting js bundle.
 -keepclassmembers class com.facebook.react.ReactInstanceManager {
     private final ** mBundleLoader;
+    private final ** mJSExceptionHandler;
 }
 
 # 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 {
@@ -14,6 +24,11 @@
 
 -keepclassmembers class * implements com.facebook.react.runtime.ReactHostDelegate {
     ** jsBundleLoader;
+    ** exceptionHandler;
+}
+
+-keepclassmembers class com.facebook.react.bridge.CatalystInstanceImpl {
+    ** mJSExceptionHandler;
 }
 
 # Preserve the Brotli decoder and its embedded static dictionary

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

@@ -149,7 +149,7 @@ interface BundleStorageService {
     fun getUsername(): String?
 
     /**
-     * Persists the optional user envelope for analytics.
+     * Persists the optional user envelope for insights.
      * Passing null clears the stored user identity.
      */
     fun setUser(

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

@@ -394,6 +394,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/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/test/java/com/hotupdater/HotUpdaterRecoveryStateTest.kt

@@ -0,0 +1,97 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+class HotUpdaterRecoveryStateTest {
+    @Test
+    fun `content queued after a fatal error cannot verify the failed bundle`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+
+        val request = requireNotNull(state.requestRecovery())
+        assertNull(state.completeLaunch())
+        state.finishRecoveryRequest(request, true)
+
+        assertNull(state.completeLaunch())
+        assertEquals(HotUpdaterRecoveryState.Launch("crashed-bundle", true), state.snapshot())
+    }
+
+    @Test
+    fun `a fatal error after first content preserves the verified bundle`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("verified-bundle", true)
+
+        assertNotNull(state.completeLaunch())
+
+        assertNull(state.requestRecovery())
+        assertNull(state.completeLaunch())
+        assertEquals(HotUpdaterRecoveryState.Launch("verified-bundle", false), state.snapshot())
+    }
+
+    @Test
+    fun `concurrent fatal errors schedule only one restart while the request is in flight`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+        val begin = CountDownLatch(1)
+        val finished = CountDownLatch(2)
+        val restartRequests = AtomicInteger()
+        val handledErrors = AtomicInteger()
+        val workers =
+            List(2) {
+                Thread {
+                    begin.await()
+                    val request = state.requestRecovery()
+                    if (request != null) {
+                        handledErrors.incrementAndGet()
+                        if (request.shouldRestart) restartRequests.incrementAndGet()
+                    }
+                    finished.countDown()
+                }.apply { start() }
+            }
+        begin.countDown()
+        assertTrue(finished.await(5, TimeUnit.SECONDS))
+        workers.forEach { it.join() }
+
+        assertEquals(2, handledErrors.get())
+        assertEquals(1, restartRequests.get())
+        assertNull(state.completeLaunch())
+    }
+
+    @Test
+    fun `a failed restart keeps the crash unverified and permits another restart request`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+        val request = requireNotNull(state.requestRecovery())
+
+        state.finishRecoveryRequest(request, false)
+
+        assertNull(state.completeLaunch())
+        val retry = requireNotNull(state.requestRecovery())
+        assertTrue(retry.shouldRestart)
+        state.finishRecoveryRequest(retry, true)
+        assertFalse(requireNotNull(state.requestRecovery()).shouldRestart)
+    }
+
+    @Test
+    fun `a previous launch restart completion cannot change the next launch`() {
+        val state = HotUpdaterRecoveryState()
+        state.start("crashed-bundle", true)
+        val request = requireNotNull(state.requestRecovery())
+        state.start("safe-bundle", false)
+
+        state.finishRecoveryRequest(request, true)
+
+        assertEquals("safe-bundle", state.completeLaunch()?.bundleId)
+        state.stop()
+        assertNull(state.snapshot())
+        assertNull(state.requestRecovery())
+    }
+}

package/android/src/test/java/com/hotupdater/PendingCrashRecoveryTest.kt

@@ -0,0 +1,44 @@
+package com.hotupdater
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+class PendingCrashRecoveryTest {
+    @get:Rule
+    val temporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `a watchdog reader waits until the native crash marker is fully written`() {
+        val marker = temporaryFolder.newFile("crash-marker.json")
+        marker.writeText("{\"bundleId\":\"crashed-bundle\",\"shouldRollback\":")
+
+        assertNull(PendingCrashRecovery.loadFromFile(marker))
+
+        marker.appendText("true}\n")
+        assertEquals(
+            PendingCrashRecovery("crashed-bundle", true),
+            PendingCrashRecovery.loadFromFile(marker),
+        )
+    }
+
+    @Test
+    fun `missing or empty markers do not request a restart`() {
+        assertNull(PendingCrashRecovery.loadFromFile(File(temporaryFolder.root, "missing.json")))
+        assertNull(PendingCrashRecovery.loadFromFile(temporaryFolder.newFile("empty.json")))
+    }
+
+    @Test
+    fun `a crash after content appeared does not request rollback`() {
+        val marker = temporaryFolder.newFile("verified-crash.json")
+        marker.writeText("{\"bundleId\":\"verified-bundle\",\"shouldRollback\":false}")
+
+        val recovery = requireNotNull(PendingCrashRecovery.loadFromFile(marker))
+        assertFalse(recovery.shouldRollback)
+        assertEquals("verified-bundle", recovery.launchedBundleId)
+    }
+}