react-native-update 10.55.0 → 10.56.0

package/android/src/main/java/cn/reactnative/modules/update/DownloadTask.java

@@ -16,6 +16,7 @@ import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.zip.ZipEntry;
+import okhttp3.Call;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.Response;
@@ -180,31 +181,6 @@ class DownloadTask implements Runnable {
         }
     }
 
-    // "bytes <start>-<end>/<total>". Returns the total (0 when "*"), or -1
-    // when the header is missing/malformed or the start does not match the
-    // local partial — either way the appended bytes could not be trusted.
-    private static long parseContentRange(String header, long expectedStart) {
-        if (header == null || !header.startsWith("bytes ")) {
-            return -1;
-        }
-        try {
-            String range = header.substring("bytes ".length()).trim();
-            int slash = range.indexOf('/');
-            int dash = range.indexOf('-');
-            if (slash < 0 || dash < 0 || dash > slash) {
-                return -1;
-            }
-            long start = Long.parseLong(range.substring(0, dash).trim());
-            if (start != expectedStart) {
-                return -1;
-            }
-            String totalPart = range.substring(slash + 1).trim();
-            return totalPart.equals("*") ? 0 : Long.parseLong(totalPart);
-        } catch (NumberFormatException e) {
-            return -1;
-        }
-    }
-
     private void downloadFile() throws IOException {
         this.hash = params.hash;
         String url = params.url;
@@ -298,7 +274,11 @@ class DownloadTask implements Runnable {
                 .build();
         }
 
-        try (Response response = requestClient.newCall(builder.build()).execute()) {
+        Call call = requestClient.newCall(builder.build());
+        // Registered so an orchestrated phase timeout can cancel it
+        // (CODE_AUDIT 2.12); cleared once the transfer is over.
+        params.attachCall(call);
+        try (Response response = call.execute()) {
             rejectProtocolDowngrade(url, response);
             if (response.code() == 416) {
                 long total = resumeMeta == null ? 0 : resumeMeta.optLong("total", 0);
@@ -335,7 +315,8 @@ class DownloadTask implements Runnable {
             long contentLength = body.contentLength();
             long totalAll;
             if (append) {
-                totalAll = parseContentRange(response.header("Content-Range"), resumeOffset);
+                totalAll = HttpUtils.parseContentRange(
+                    response.header("Content-Range"), resumeOffset);
                 if (totalAll < 0) {
                     // Malformed or mismatched Content-Range: treat like a
                     // stale partial (one clean retry from zero) instead of
@@ -371,6 +352,13 @@ class DownloadTask implements Runnable {
             long received = 0;
             int currentPercentage = 0;
             long lastPostedBytes = baseOffset;
+            // Unknown length: the response-time check could only reserve the
+            // margin, so the disk is probed before any write that would run
+            // past the bytes reserved so far, each probe reserving at least
+            // the next PROBE bytes (more when one chunk is larger) — no write
+            // can ever eat into the margin (the archive cap alone is far more
+            // than the margin). A throw keeps the partial for a later attempt.
+            long freeSpaceReservedUntil = 0;
 
             try (
                 BufferedSource source = body.source();
@@ -379,6 +367,20 @@ class DownloadTask implements Runnable {
             ) {
                 while ((bytesRead = source.read(sink.buffer(), DOWNLOAD_CHUNK_SIZE)) != -1) {
                     received += bytesRead;
+                    if (totalAll <= 0 && received > freeSpaceReservedUntil) {
+                        long reserve = Math.max(
+                            ArchiveLimits.UNKNOWN_LENGTH_FREE_SPACE_PROBE_BYTES, bytesRead);
+                        freeSpaceReservedUntil = received - bytesRead + reserve;
+                        try {
+                            ArchiveLimits.ensureFreeSpace(writePath, reserve);
+                        } catch (IOException e) {
+                            // The chunk is still only buffered; closing the
+                            // sink would flush it onto the disk that just
+                            // failed the probe.
+                            sink.buffer().clear();
+                            throw e;
+                        }
+                    }
                     sink.emit();
 
                     long overall = baseOffset + received;
@@ -414,6 +416,8 @@ class DownloadTask implements Runnable {
             if (baseOffset + received != lastPostedBytes) {
                 postProgress(baseOffset + received, totalAll);
             }
+        } finally {
+            params.attachCall(null);
         }
         return true;
     }
@@ -576,6 +580,14 @@ class DownloadTask implements Runnable {
      */
     private void promoteStaging() throws IOException, JSONException {
         File work = stagingDirectory();
+        if (targetsRunningVersion()) {
+            // The process switched to this very version while the task ran
+            // (a restartApp racing the download): never rename over the
+            // live directory. Its verified install stands; staging goes.
+            ensureNotReinstallingRunningVersion();
+            UpdateFileUtils.removeDirectory(work);
+            return;
+        }
         File bundle = new File(work, "index.bundlejs");
         if (!bundle.isFile()) {
             throw new IOException("bundle missing after install: " + bundle);
@@ -589,6 +601,12 @@ class DownloadTask implements Runnable {
         if (!work.renameTo(params.unzipDirectory)) {
             throw new IOException("failed to promote staging directory to " + params.unzipDirectory);
         }
+        // The rename rewrote the versions root's entries; the record's own
+        // directory was synced by InstallRecord.write, the root was not.
+        File versionsRoot = params.unzipDirectory.getParentFile();
+        if (versionsRoot != null) {
+            InstallRecord.syncDirectory(versionsRoot);
+        }
     }
 
     /**
@@ -695,11 +713,18 @@ class DownloadTask implements Runnable {
     }
 
     private void doCleanUp() {
-        cleanupOldEntries(
-            params.unzipDirectory.getAbsolutePath(),
-            params.hash,
-            params.originHash,
-            params.maxAgeDays
+        UpdateContext.getInstance(context).runCleanupWithLatestState(
+            new UpdateContext.CleanupAction() {
+                @Override
+                public void run(String keepCurrent, String keepPrevious) {
+                    cleanupOldEntries(
+                        params.unzipDirectory.getAbsolutePath(),
+                        keepCurrent,
+                        keepPrevious,
+                        params.maxAgeDays
+                    );
+                }
+            }
         );
     }
 
@@ -768,13 +793,51 @@ class DownloadTask implements Runnable {
             && InstallRecord.isComplete(params.unzipDirectory, params.hash);
     }
 
+    // True when this task targets the version the process is running from.
+    private boolean targetsRunningVersion() {
+        String running = UpdateContext.runningVersion();
+        return running != null && params.hash != null && running.equals(params.hash);
+    }
+
+    /**
+     * The running version's directory is never replaced in place
+     * (CODE_AUDIT 2.10): images and fonts are read from it on demand, and an
+     * install from before completion records existed has no marker, so a
+     * re-download of the same hash would wipe the live directory. A running
+     * version whose record verifies against the bundle on disk needs no
+     * install and passes; anything else is refused as a file-operation
+     * failure rather than overwritten.
+     */
+    private void ensureNotReinstallingRunningVersion() throws IOException {
+        File bundle = new File(params.unzipDirectory, "index.bundlejs");
+        if (bundle.isFile() && InstallRecord.isComplete(params.unzipDirectory, params.hash)) {
+            try {
+                InstallRecord.verifyForActivation(params.unzipDirectory, params.hash, bundle);
+                return;
+            } catch (IOException e) {
+                throw new FileOperationException("Running version " + params.hash
+                    + " cannot be reinstalled in place: " + e.getMessage());
+            }
+        }
+        throw new FileOperationException("Running version " + params.hash
+            + " has no verifiable install record and cannot be reinstalled in place");
+    }
+
     @Override
     public void run() {
         int taskType = params.type;
+        final boolean runningVersion = isPatchTask(taskType) && targetsRunningVersion();
         final boolean alreadyCompleted = isPatchTask(taskType)
             && hasCompletedPatchDirectory();
         try {
-            if (alreadyCompleted) {
+            if (params.isCancelled()) {
+                throw new IOException("download task cancelled before it started");
+            }
+            if (runningVersion) {
+                ensureNotReinstallingRunningVersion();
+                Log.i(UpdateContext.TAG, "download task: version " + params.hash
+                    + " is running in this process and already installed");
+            } else if (alreadyCompleted) {
                 Log.i(UpdateContext.TAG,
                     "download task: version " + params.hash + " already completed");
             } else {
@@ -818,7 +881,8 @@ class DownloadTask implements Runnable {
                 Throwable classified = error;
                 if (downloadPhaseCompleted
                     && isPatchTask(taskType)
-                    && !(error instanceof PatchFailedException)) {
+                    && !(error instanceof PatchFailedException)
+                    && !(error instanceof FileOperationException)) {
                     classified = new PatchFailedException(
                         String.valueOf(error.getMessage()), error);
                 }

package/android/src/main/java/cn/reactnative/modules/update/DownloadTaskParams.java

@@ -27,4 +27,33 @@ class DownloadTaskParams {
     File        unzipDirectory;
     File        originDirectory;
     UpdateContext.DownloadFileListener listener;
+
+    // Cooperative cancellation for orchestrated downloads (CODE_AUDIT 2.12):
+    // the native check cancels a task whose phase budget expired, so it
+    // neither starts late on the single download thread nor keeps
+    // transferring behind the next attempt. Guarded by this.
+    private boolean cancelled;
+    private okhttp3.Call activeCall;
+
+    synchronized void cancel() {
+        cancelled = true;
+        if (activeCall != null) {
+            activeCall.cancel();
+        }
+    }
+
+    synchronized boolean isCancelled() {
+        return cancelled;
+    }
+
+    /**
+     * Registers the transfer in flight (null clears it); a task cancelled
+     * before its transfer started cancels the call right here.
+     */
+    synchronized void attachCall(okhttp3.Call call) {
+        activeCall = call;
+        if (cancelled && call != null) {
+            call.cancel();
+        }
+    }
 }

package/android/src/main/java/cn/reactnative/modules/update/FileOperationException.java

@@ -0,0 +1,15 @@
+package cn.reactnative.modules.update;
+
+import java.io.IOException;
+
+/**
+ * A download task refused by a local file-system rule rather than by the
+ * network or the patch itself — today: reinstalling the version this process
+ * is running from in place (DownloadTask.ensureNotReinstallingRunningVersion).
+ * UpdateModuleImpl rejects these with FILE_OPERATION_FAILED.
+ */
+class FileOperationException extends IOException {
+    FileOperationException(String message) {
+        super(message);
+    }
+}

package/android/src/main/java/cn/reactnative/modules/update/HttpUtils.java

@@ -0,0 +1,59 @@
+package cn.reactnative.modules.update;
+
+/**
+ * Pure string helpers for the HTTP paths (no Android or OkHttp types), kept
+ * apart from DownloadTask / NativeCheckOrchestrator so they stay testable on
+ * a plain JVM: DownloadTask loads librnupdate.so in its static initializer
+ * and both pull in OkHttp.
+ */
+final class HttpUtils {
+    private HttpUtils() {
+    }
+
+    /** True for an "https:" URL, case-insensitively; false for anything else (incl. null). */
+    static boolean isHttpsUrl(String url) {
+        return url != null && url.regionMatches(true, 0, "https://", 0, 8);
+    }
+
+    /** Strips every trailing slash so "<base>/checkUpdate/<appKey>" never doubles one. */
+    static String normalizeEndpointBase(String base) {
+        while (base.endsWith("/")) {
+            base = base.substring(0, base.length() - 1);
+        }
+        return base;
+    }
+
+    // "bytes <start>-<end>/<total>". Returns the total (0 when "*"), or -1
+    // when the header is missing/malformed, the start does not match the
+    // local partial, or the range and total contradict each other (end
+    // before start, or a numeric total not beyond the end) — either way the
+    // appended bytes could not be trusted. A total of 0 would otherwise pass
+    // as "unknown" and skip the final size check (RFC 9110 §14.4: the
+    // complete length must exceed the last position).
+    static long parseContentRange(String header, long expectedStart) {
+        if (header == null || !header.startsWith("bytes ")) {
+            return -1;
+        }
+        try {
+            String range = header.substring("bytes ".length()).trim();
+            int slash = range.indexOf('/');
+            int dash = range.indexOf('-');
+            if (slash < 0 || dash < 0 || dash > slash) {
+                return -1;
+            }
+            long start = Long.parseLong(range.substring(0, dash).trim());
+            long end = Long.parseLong(range.substring(dash + 1, slash).trim());
+            if (start != expectedStart || end < start) {
+                return -1;
+            }
+            String totalPart = range.substring(slash + 1).trim();
+            if (totalPart.equals("*")) {
+                return 0;
+            }
+            long total = Long.parseLong(totalPart);
+            return total > end ? total : -1;
+        } catch (NumberFormatException e) {
+            return -1;
+        }
+    }
+}

package/android/src/main/java/cn/reactnative/modules/update/InstallRecord.java

@@ -1,5 +1,7 @@
 package cn.reactnative.modules.update;
 
+import android.os.Build;
+import android.util.Log;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
@@ -39,7 +41,11 @@ final class InstallRecord {
         return record.toString();
     }
 
-    /** Writes the record and fsyncs it: the rename that follows must find it on disk. */
+    /**
+     * Writes the record and fsyncs it, then the directory holding it: the
+     * rename that follows must find the record on disk, and the new
+     * directory entry is only durable once the directory itself is synced.
+     */
     static void write(File versionDir, String recordJson) throws IOException {
         File file = new File(versionDir, FILE_NAME);
         try (FileOutputStream out = new FileOutputStream(file)) {
@@ -47,6 +53,26 @@ final class InstallRecord {
             out.flush();
             out.getFD().sync();
         }
+        syncDirectory(versionDir);
+    }
+
+    // java.nio.file (the only way to open a directory for fsync from Java)
+    // is API 26+ on Android; below that the file fsync above is all there
+    // is. Best-effort by design: a file system that refuses to open a
+    // directory for reading must not fail the install. Also called by the
+    // installer on the versions root after the staging -> version rename:
+    // that rename changes the parent's entries, which only the parent's own
+    // sync makes durable.
+    static void syncDirectory(File dir) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+        try (java.nio.channels.FileChannel channel = java.nio.channels.FileChannel.open(
+                dir.toPath(), java.nio.file.StandardOpenOption.READ)) {
+            channel.force(true);
+        } catch (Throwable e) {
+            Log.w("pushy", "Directory fsync skipped for " + dir + ": " + e);
+        }
     }
 
     /**

package/android/src/main/java/cn/reactnative/modules/update/NativeCheckOrchestrator.java

@@ -2,6 +2,10 @@ package cn.reactnative.modules.update;
 
 import android.os.Build;
 import android.util.Log;
+import androidx.annotation.Nullable;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.HashSet;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -11,6 +15,8 @@ import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.RequestBody;
 import okhttp3.Response;
+import okhttp3.ResponseBody;
+import okio.BufferedSource;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
@@ -35,6 +41,9 @@ final class NativeCheckOrchestrator {
     static final String KEY_ROUND_INCOMPLETE = "nativeCheckIncomplete";
     private static final int MAX_CHECK_HTTP_ATTEMPTS = 8;
     private static final long DOWNLOAD_PHASE_TIMEOUT_SECONDS = 600;
+    // The check response (and a remote queryUrls list) is a small JSON
+    // document; anything bigger is a broken or hijacked endpoint.
+    private static final long MAX_CHECK_RESPONSE_BYTES = 1024 * 1024;
 
     private static final AtomicBoolean scheduled = new AtomicBoolean(false);
     // One round per process, whoever starts it first — the delayed cold-start
@@ -177,7 +186,8 @@ final class NativeCheckOrchestrator {
 
     // The alert-strategy variant of the §10.7 hole: the round downloaded a
     // fix but deferred activation to JS, and JS is now dead. Activation is
-    // local and bounded (a state switch under the commit lock).
+    // local and bounded (the bundle digest, then a state switch under the
+    // commit lock).
     private static void activatePendingVersion(UpdateContext context) {
         String hash = unactivatedHash;
         if (hash == null) {
@@ -341,7 +351,7 @@ final class NativeCheckOrchestrator {
             return;
         }
         String hash = decision.optString("hash", "");
-        if (!UpdateContext.isSafePathComponent(hash)) {
+        if (!UpdateFileUtils.isSafePathComponent(hash)) {
             return;
         }
 
@@ -467,16 +477,43 @@ final class NativeCheckOrchestrator {
                 // Same rule as the artifact download: an https endpoint that
                 // redirects to plaintext http is a failed endpoint.
                 DownloadTask.rejectProtocolDowngrade(url, response);
-                if (!response.isSuccessful() || response.body() == null) {
+                ResponseBody body = response.body();
+                if (!response.isSuccessful() || body == null) {
                     return null;
                 }
-                return response.body().string();
+                return readBoundedBody(body);
             }
         } catch (Exception e) {
+            // One line per failed endpoint; the fallback chain is otherwise
+            // invisible in the field.
+            Log.w(UpdateContext.TAG, "native check: request failed with "
+                + e.getClass().getName() + ": " + e.getMessage());
             return null;
         }
     }
 
+    /**
+     * Reads the body with a hard cap (CODE_AUDIT 2.7): a hijacked endpoint
+     * must not be able to OOM this thread with an unbounded string. Over the
+     * cap counts as a failed endpoint (null), like any other bad response.
+     */
+    @Nullable
+    private static String readBoundedBody(ResponseBody body) throws IOException {
+        if (body.contentLength() > MAX_CHECK_RESPONSE_BYTES) {
+            return null;
+        }
+        BufferedSource source = body.source();
+        if (source.request(MAX_CHECK_RESPONSE_BYTES + 1)) {
+            Log.w(UpdateContext.TAG, "native check: response exceeds "
+                + MAX_CHECK_RESPONSE_BYTES + " bytes, ignoring endpoint");
+            return null;
+        }
+        MediaType contentType = body.contentType();
+        Charset charset = contentType == null
+            ? null : contentType.charset(StandardCharsets.UTF_8);
+        return source.readString(charset == null ? StandardCharsets.UTF_8 : charset);
+    }
+
     // Shared schema rule (update_flow_core::IsValidCheckResponse): a 200 with
     // `{"error": ...}` is a failed endpoint, not a verdict, and must not stop
     // the endpoint fallback.
@@ -484,13 +521,6 @@ final class NativeCheckOrchestrator {
         return responseText != null && NativeUpdateFlow.isValidCheckResponse(responseText);
     }
 
-    private static String normalizeEndpointBase(String base) {
-        while (base.endsWith("/")) {
-            base = base.substring(0, base.length() - 1);
-        }
-        return base;
-    }
-
     /**
      * Sequential fallback over the ordered candidates (§5.1): one request at
      * a time with its own timeout; after the configured round fails,
@@ -513,7 +543,7 @@ final class NativeCheckOrchestrator {
         HashSet<String> tried = new HashSet<>();
         int httpAttempts = 0;
         for (int i = 0; i < ordered.length(); i++) {
-            String base = normalizeEndpointBase(ordered.optString(i, ""));
+            String base = HttpUtils.normalizeEndpointBase(ordered.optString(i, ""));
             if (base.isEmpty() || !tried.add(base)) {
                 continue;
             }
@@ -549,7 +579,7 @@ final class NativeCheckOrchestrator {
                 continue;
             }
             for (int j = 0; j < remote.length(); j++) {
-                String base = normalizeEndpointBase(remote.optString(j, ""));
+                String base = HttpUtils.normalizeEndpointBase(remote.optString(j, ""));
                 if (base.isEmpty() || tried.contains(base)) {
                     continue;
                 }
@@ -644,20 +674,28 @@ final class NativeCheckOrchestrator {
                             latch.countDown();
                         }
                     };
+                DownloadTaskParams task;
                 if ("diff".equals(type)) {
-                    context.downloadPatchFromPpk(
+                    task = context.downloadPatchFromPpk(
                         url, hash, originHash, listener, deadlineNanos);
                 } else if ("pdiff".equals(type)) {
-                    context.downloadPatchFromApk(
+                    task = context.downloadPatchFromApk(
                         url, hash, listener, deadlineNanos);
                 } else {
-                    context.downloadFullUpdate(
+                    task = context.downloadFullUpdate(
                         url, hash, listener, deadlineNanos);
                 }
                 try {
                     if (!latch.await(remainingNanos, TimeUnit.NANOSECONDS)) {
                         Log.w(UpdateContext.TAG,
                             "native check: download phase timed out during " + type);
+                        // The task shares one download thread with the next
+                        // attempt: cancel its transfer (or keep it from
+                        // starting) instead of queueing behind it
+                        // (CODE_AUDIT 2.12).
+                        if (task != null) {
+                            task.cancel();
+                        }
                         if (isFullAttempt) {
                             return false;
                         }
@@ -665,6 +703,9 @@ final class NativeCheckOrchestrator {
                     }
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
+                    if (task != null) {
+                        task.cancel();
+                    }
                     return false;
                 }
                 if (succeeded.get()) {

package/android/src/main/java/cn/reactnative/modules/update/ReactReloadManager.java

@@ -18,18 +18,35 @@ final class ReactReloadManager {
     private ReactReloadManager() {
     }
 
-    static void restartApp(
-        UpdateContext updateContext,
-        ReactApplicationContext reactContext,
-        @Nullable String hash
-    ) throws Throwable {
+    /**
+     * First half of a restart, for the state serial thread: activate the
+     * requested version (bundle digest + commit) and resolve the bundle to
+     * load. Nothing here touches React, so nothing here needs the UI thread
+     * (CODE_AUDIT 2.2). Returns the bundle path, or null for the packaged
+     * bundle.
+     */
+    @Nullable
+    static String prepareRestart(UpdateContext updateContext, @Nullable String hash) {
         if (hash != null) {
             updateContext.switchVersion(hash);
         }
+        return updateContext.getBundleUrl();
+    }
 
+    /**
+     * Second half, for the UI thread: point the running React instance at
+     * {@code updateBundlePath} and reload it. Throws when no supported
+     * injection worked — the caller rejects RESTART_FAILED. There is
+     * deliberately no Activity.recreate() fallback: it would reload the
+     * previous bundle while the promise reported success (CODE_AUDIT 2.9).
+     */
+    static void reload(
+        UpdateContext updateContext,
+        ReactApplicationContext reactContext,
+        @Nullable String updateBundlePath
+    ) throws Throwable {
         Context application = reactContext.getApplicationContext();
         Activity currentActivity = reactContext.getCurrentActivity();
-        String updateBundlePath = updateContext.getBundleUrl();
 
         boolean newArchitectureEnabled = isNewArchitectureEnabled(application);
         Object reactHost = newArchitectureEnabled ? getReactHost(currentActivity, application) : null;
@@ -38,53 +55,28 @@ final class ReactReloadManager {
                 reloadReactHost(reactHost, createBundleLoader(application, updateBundlePath, true));
                 return;
             } catch (Throwable err) {
-                Log.e(UpdateContext.TAG, "Failed to reload via ReactHost", err);
+                Log.e(UpdateContext.TAG,
+                    "Failed to reload via ReactHost, trying ReactInstanceManager", err);
             }
         }
 
         JSBundleLoader loader = createBundleLoader(application, updateBundlePath, false);
-        try {
-            ReactInstanceManager instanceManager =
-                resolveReactInstanceManager(updateContext, application);
+        ReactInstanceManager instanceManager =
+            resolveReactInstanceManager(updateContext, application);
 
-            try {
-                Field loadField = instanceManager.getClass().getDeclaredField("mBundleLoader");
-                loadField.setAccessible(true);
-                loadField.set(instanceManager, loader);
-            } catch (Throwable err) {
-                Field jsBundleField = instanceManager.getClass().getDeclaredField("mJSBundleFile");
-                jsBundleField.setAccessible(true);
-                jsBundleField.set(instanceManager, updateContext.getBundleUrl());
-            }
-
-            instanceManager.recreateReactContextInBackground();
+        // Java (mBundleLoader / mJSBundleFile) and Kotlin (bundleLoader /
+        // jsBundleFile) spellings of the private fields are both tried.
+        try {
+            Field loadField = getCompatibleField(instanceManager.getClass(), "bundleLoader");
+            loadField.setAccessible(true);
+            loadField.set(instanceManager, loader);
         } catch (Throwable err) {
-            if (currentActivity == null) {
-                throw err;
-            }
-
-            try {
-                if (!newArchitectureEnabled) {
-                    throw err;
-                }
-                Object currentReactHost = getReactHost(currentActivity, application);
-                if (currentReactHost == null) {
-                    throw err;
-                }
-                reloadReactHost(
-                    currentReactHost,
-                    createBundleLoader(application, updateBundlePath, true)
-                );
-            } catch (Throwable reloadError) {
-                Log.e(
-                    UpdateContext.TAG,
-                    "Failed to reload via ReactHost, falling back to Activity.recreate() "
-                        + "(this may load the previous bundle until next cold start)",
-                    reloadError
-                );
-                currentActivity.recreate();
-            }
+            Field jsBundleField = getCompatibleField(instanceManager.getClass(), "jsBundleFile");
+            jsBundleField.setAccessible(true);
+            jsBundleField.set(instanceManager, updateBundlePath);
         }
+
+        instanceManager.recreateReactContextInBackground();
     }
 
     private static Field getCompatibleField(Class<?> clazz, String fieldName)