@revopush/react-native-code-push 2.5.1 → 2.5.2

package/.claude/settings.local.json

@@ -3,7 +3,11 @@
     "allow": [
       "Bash(git:*)",
       "Bash(echo \"EXIT:$?\")",
-      "Bash(find:*)"
+      "Bash(find:*)",
+      "Bash(cd ios/CodePush)",
+      "Bash(grep -rln \"finalizePatchAndZip\\\\|DiffDownloadHandler\\\\|HDIFF\\\\|hpatch\\\\|createZipFileAtPath\\\\|bundleDiffBlob\" .)",
+      "Bash(grep -rln \"finalizePatchAndZip\\\\|DiffDownloadHandler\\\\|hpatch\\\\|HDIFF\\\\|createZipFileAtPath\" ios)",
+      "Bash(grep -v \".framework/DiffUpdates$\")"
     ]
   }
 }

package/README.md

@@ -53,7 +53,8 @@ We try our best to maintain backwards compatibility of our plugin with previous
 | 0.76, 0.77, 0.78, 0.79  | v1.0+ *(Support both New and Old Architectures)*                                                     |
 | v0.80                   | v1.2                                                                                                 |
 | Expo sdk 52             | v1.3                                                                                                 | 
-| v0.81                   | v1.5                                                                                                 |
+| v0.81, v0.82            | v1.5                                                                                                 |
+| v0.83, expo 55          | v1.6                                                                                                 |
 
 
 We work hard to respond to new RN releases, but they do occasionally break us. We will update this chart with each RN release, so that users can check to see what our "official" support is.

package/android/build.gradle

@@ -43,12 +43,20 @@ android {
     lint {
         abortOnError = false
     }
+
+    testOptions {
+        unitTests.returnDefaultValues = true
+        unitTests.all {
+            testLogging { events "passed", "skipped", "failed" }
+        }
+    }
 }
 
 dependencies {
     if (boolProp("REACT_NATIVE_REVOPUSH_DEV_MODE", false)) {
         // for local dev only
         implementation("org.revopush:revopush-diff")
+        // @react-native/gradle-plugin in package.json must use this same version
         implementation 'com.facebook.react:react-android:0.79.6'
         // end of local dev only
     } else {
@@ -56,9 +64,12 @@ dependencies {
         // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
         //noinspection GradleDynamicVersion
 
-        implementation "org.revopush:revopush-diff:0.0.7"
+        implementation "org.revopush:revopush-diff:0.0.9"
         implementation "com.facebook.react:react-native:+"
     }
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.json:json:20231013'
 }
 
 def getExtOrIntegerDefault(name, defaultValue) {

package/android/codepush.gradle

@@ -5,7 +5,6 @@ import java.nio.file.Paths;
 def config = project.extensions.findByName("react") ?: [:]
 def bundleAssetName = config.bundleAssetName ? config.bundleAssetName.get() : "index.android.bundle"
 
-// because elvis operator
 def elvisFile(thing) {
     return thing ? file(thing) : null;
 }
@@ -18,30 +17,12 @@ void runBefore(String dependentTaskName, Task task) {
 }
 
 /**
- * Finds the path of the installed npm package with the given name using Node's
- * module resolution algorithm, which searches "node_modules" directories up to
- * the file system root. This handles various cases, including:
- *
- *   - Working in the open-source RN repo:
- *       Gradle: /path/to/react-native/ReactAndroid
- *       Node module: /path/to/react-native/node_modules/[package]
- *
- *   - Installing RN as a dependency of an app and searching for hoisted
- *     dependencies:
- *       Gradle: /path/to/app/node_modules/react-native/ReactAndroid
- *       Node module: /path/to/app/node_modules/[package]
- *
- *   - Working in a larger repo (e.g., Facebook) that contains RN:
- *       Gradle: /path/to/repo/path/to/react-native/ReactAndroid
- *       Node module: /path/to/repo/node_modules/[package]
- *
- * The search begins at the given base directory (a File object). The returned
- * path is a string.
+ * Resolves an installed npm package the way Node does: walk up from baseDir looking for
+ * node_modules/<packageName>. Covers app, hoisted and monorepo layouts alike.
  */
 static def findNodeModulePath(baseDir, packageName) {
     def basePath = baseDir.toPath().normalize()
-    // Node's module resolution algorithm searches up to the root directory,
-    // after which the base path will be null
+    // null once the walk passes the filesystem root
     while (basePath) {
         def candidatePath = Paths.get(basePath.toString(), "node_modules", packageName)
         if (candidatePath.toFile().exists()) {
@@ -56,7 +37,6 @@ gradle.projectsEvaluated {
     def debuggableVariants = config.debuggableVariants ? config.debuggableVariants.get() : ['debug']
 
     android.applicationVariants.all { variant ->
-        // No code push for debuggable variants
         if (debuggableVariants.contains(variant.name)) {
             return;
         }
@@ -75,11 +55,9 @@ gradle.projectsEvaluated {
         def resourcesDir;
         def jsBundleFile;
 
-        // Additional node commandline arguments
         def nodeExecutableAndArgs = config.nodeExecutableAndArgs ? config.nodeExecutableAndArgs.get() : ["node"]
         def extraPackagerArgs = config.extraPackagerArgs ? config.extraPackagerArgs.get() : []
 
-        // Make this task run right after the bundle task
         def generateBundledResourcesHash;
 
         def reactBundleTask = tasks.findByName("createBundle${targetName}JsAndAssets")
@@ -99,8 +77,6 @@ gradle.projectsEvaluated {
                     name: "generateBundledResourcesHash${targetName}",
                     type: Exec) {
                 commandLine(*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir)
-
-                enabled !debuggableVariants.contains(variant.name) ?: targetName.toLowerCase().contains("release")
             }
 
             runBefore("merge${targetName}Resources", generateBundledResourcesHash)
@@ -114,9 +90,7 @@ gradle.projectsEvaluated {
             resourcesDir = elvisFile(config."${resourcesDirConfigName}") ? elvisFile(config."${resourcesDirConfigName}").get() :
                     file("$buildDir/intermediates/res/merged/${targetPath}")
 
-            // In case version of 'Android Plugin for Gradle'' is lower than 1.3.0
-            // '$buildDir' has slightly different structure - 'merged' folder
-            // does not exists so '${targetPath}' folder contains directly in 'res' folder.
+            // AGP below 1.3.0 had no 'merged' folder: res/${targetPath} directly.
             if (!resourcesDir.exists() && file("$buildDir/intermediates/res/${targetPath}").exists()) {
                 resourcesDir = file("$buildDir/intermediates/res/${targetPath}")
             }
@@ -131,7 +105,6 @@ gradle.projectsEvaluated {
                 commandLine(*nodeExecutableAndArgs, "${nodeModulesPath}/scripts/generateBundledResourcesHash.js", resourcesDir, jsBundleFile, jsBundleDir, resourcesMapTempFileName)
             }
 
-            // Make this task run right before the bundle task
             def recordFilesBeforeBundleCommand = tasks.create(
                     name: "recordFilesBeforeBundleCommand${targetName}",
                     type: Exec) {
@@ -142,7 +115,7 @@ gradle.projectsEvaluated {
             recordFilesBeforeBundleCommand.dependsOn("merge${targetName}Assets")
             runBefore("bundle${targetName}JsAndAssets", recordFilesBeforeBundleCommand)
 
-            // We need to generate and record the resources map, but we use it to generate the bundle hash
+            // the map recorded before bundling is the input to the hash
             generateBundledResourcesHash.dependsOn("recordFilesBeforeBundleCommand${targetName}")
         }
 
@@ -155,20 +128,24 @@ gradle.projectsEvaluated {
     }
 }
 
-project.extensions.findByName("androidComponents")?.finalizeDsl { extension ->
-    // This disables density-based APK splitting for the App Bundle
-    extension.bundle.density.enableSplit = false
+// withPlugin, not findByName: applying this script above the Android plugin would otherwise
+// silently ship an APK with no CODE_PUSH_APK_BUILD_TIME.
+project.pluginManager.withPlugin("com.android.application") {
+    project.extensions.getByName("androidComponents").finalizeDsl { extension ->
+        // One density bucket per device would make the build-time resources hash unreproducible.
+        extension.bundle.density.enableSplit = false
 
-    extension.androidResources.noCompress += "png"
+        extension.androidResources.noCompress.add("png")
 
-    extension.buildTypes.all { buildType ->
-        // disable PNG crunching for release builds to align APK resources with what Metro builds
-        if(!buildType.debuggable){
-            crunchPngs = false
-        }
+        extension.buildTypes.all { buildType ->
+            // crunching would change the bytes Metro already hashed
+            if (!buildType.debuggable) {
+                buildType.crunchPngs = false
+            }
 
-        // to prevent incorrect long value restoration from strings.xml we need to wrap it with double quotes
-        // https://github.com/microsoft/cordova-plugin-code-push/issues/264
-        buildType.resValue('string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis()))
+            // quoted, or the long is restored incorrectly from strings.xml
+            // https://github.com/microsoft/cordova-plugin-code-push/issues/264
+            buildType.resValue('string', "CODE_PUSH_APK_BUILD_TIME", String.format("\"%d\"", System.currentTimeMillis()))
+        }
     }
 }

package/android/gradle.properties

@@ -18,3 +18,5 @@
 # org.gradle.parallel=true
 
 #android.useDeprecatedNdk=true
+
+android.useAndroidX=true

package/android/proguard-rules.pro

@@ -18,16 +18,32 @@
 
 # Invoked via reflection, when setting js bundle.
 -keepclassmembers class com.facebook.react.ReactInstanceManager {
-    private final ** mBundleLoader;
+    private ** mBundleLoader;
+    private ** mAttachedReactRoots;
+    private ** mAttachedRootViews;
 }
 
 -keepclassmembers class com.facebook.react.runtime.ReactHostImpl {
-    private final ** reactHostDelegate;
+    private ** mReactHostDelegate;
+    private ** reactHostDelegate;
 }
 
 -keep interface com.facebook.react.runtime.ReactHostDelegate { *; }
 
 -keep class * implements com.facebook.react.runtime.ReactHostDelegate { *; }
 
+-keepclassmembers class * implements com.facebook.react.runtime.ReactHostDelegate {
+    private ** jsBundleLoader;
+    private ** _jsBundleLoader;
+}
+
+-keepclassmembers interface com.facebook.react.ReactRoot {
+    public ** getRootViewGroup();
+}
+
+-keepclassmembers class * implements com.facebook.react.ReactRoot {
+    public ** getRootViewGroup();
+}
+
 # Can't find referenced class org.bouncycastle.**
 -dontwarn com.nimbusds.jose.**

package/android/settings.gradle

@@ -1,3 +1,5 @@
+// Only used when this directory is its own Gradle build root (standalone or monorepo).
+// Autolinked apps include it as a subproject, so their settings file is used instead.
 pluginManagement {
     repositories {
         mavenCentral()
@@ -10,22 +12,19 @@ pluginManagement {
         id("com.android.library") version "8.8.2" apply false
     }
 
-    // to satisfy apply plugin: "com.facebook.react" as a part of monorepo
-    def gradlePluginPath = getProperty("REACT_NATIVE_GRADLE_PLUGIN_PATH")
-    if (gradlePluginPath != null) {
+    // Inline, not via a helper: method calls inside pluginManagement {} bind to the block's
+    // delegate and never reach this script's own methods. Property access on `settings` does.
+    def gradlePluginPath = (settings.hasProperty("REACT_NATIVE_GRADLE_PLUGIN_PATH") ? settings["REACT_NATIVE_GRADLE_PLUGIN_PATH"] : null) ?: System.getenv("REACT_NATIVE_GRADLE_PLUGIN_PATH")
+    if (gradlePluginPath) {
         includeBuild(gradlePluginPath)
     }
 }
 
-def diffPath = getProperty("REACT_NATIVE_REVOPUSH_DIFF_PATH")
-if (diffPath != null) {
+def diffPath = (settings.hasProperty("REACT_NATIVE_REVOPUSH_DIFF_PATH") ? settings["REACT_NATIVE_REVOPUSH_DIFF_PATH"] : null) ?: System.getenv("REACT_NATIVE_REVOPUSH_DIFF_PATH")
+if (diffPath) {
     includeBuild(diffPath) {
         dependencySubstitution {
             substitute(module("org.revopush:revopush-diff")).using(project(":revopush-diff"))
         }
     }
 }
-
-def getProperty(propName) {
-    return settings[propName] ?: System.getenv(propName)
-}

package/android/src/main/java/com/microsoft/codepush/react/BaseBundleStore.java

@@ -0,0 +1,78 @@
+package com.microsoft.codepush.react;
+
+import static org.revopush.ota.utils.FileUtils.copyFileIfExists;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+
+/** Bundles kept as diff bases, named by the package hash of the release they came from. */
+public class BaseBundleStore {
+
+    public static final int MAX_SAVED_BASES = 3;
+
+    private final File mBasesDir;
+
+    public BaseBundleStore(String basesDirPath) {
+        mBasesDir = new File(basesDirPath);
+    }
+
+    public File lookup(String packageHash) {
+        if (!isValidEntryName(packageHash)) return null;
+        File file = new File(mBasesDir, packageHash);
+        return file.isFile() ? file : null;
+    }
+
+    /**
+     * Copies the bundle into the store, so it outlives its package folder. A hard link would
+     * be cheaper, but SELinux denies untrusted_app the link permission on its own files.
+     * Never fails an update.
+     */
+    public boolean save(File sourceBundle, String packageHash) {
+        if (sourceBundle == null || !sourceBundle.isFile()) return false;
+        if (!isValidEntryName(packageHash)) return false;
+
+        File dest = new File(mBasesDir, packageHash);
+        if (dest.isFile()) {
+            // Saving is the moment the base gets used, so this keeps evict() ordered by last use.
+            dest.setLastModified(System.currentTimeMillis());
+            return true;
+        }
+
+        // Copied aside and renamed: a copy cut short by process death must not leave a truncated
+        // file under the hash, which lookup() would hand out forever.
+        File temp = new File(mBasesDir, packageHash + ".tmp");
+        try {
+            if (!copyFileIfExists(sourceBundle, temp) || !temp.renameTo(dest)) {
+                FileUtils.deleteFileOrFolderSilently(temp);
+                return false;
+            }
+        } catch (IOException e) {
+            CodePushUtils.log("Could not save base bundle: " + e.getMessage());
+            FileUtils.deleteFileOrFolderSilently(temp);
+            return false;
+        }
+        evict();
+        return true;
+    }
+
+    /** The hash names a file directly inside the store, so it may not steer out of it. */
+    private static boolean isValidEntryName(String packageHash) {
+        return packageHash != null
+                && !packageHash.isEmpty()
+                && !packageHash.equals(".")
+                && !packageHash.equals("..")
+                && packageHash.indexOf('/') < 0
+                && packageHash.indexOf('\\') < 0;
+    }
+
+    /** Keeps the MAX_SAVED_BASES most recently used entries. */
+    private void evict() {
+        File[] files = mBasesDir.listFiles();
+        if (files == null || files.length <= MAX_SAVED_BASES) return;
+        Arrays.sort(files, (a, b) -> Long.compare(a.lastModified(), b.lastModified()));
+        for (int i = 0; i < files.length - MAX_SAVED_BASES; i++) {
+            FileUtils.deleteFileOrFolderSilently(files[i]);
+        }
+    }
+}

package/android/src/main/java/com/microsoft/codepush/react/CodePush.java

@@ -4,6 +4,7 @@ import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
+import android.os.Build;
 
 import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceManager;
@@ -44,7 +45,7 @@ public class CodePush implements ReactPackage {
 
     private boolean mDidUpdate = false;
 
-    private String mAssetsBundleFileName;
+    private String mAssetsBundleFileName = CodePushConstants.DEFAULT_JS_BUNDLE_NAME;
 
     // Helper classes.
     private CodePushUpdateManager mUpdateManager;
@@ -83,11 +84,13 @@ public class CodePush implements ReactPackage {
         mSettingsManager = new SettingsManager(mContext);
         bundleMetadataManager = new NativeBundleManager(mContext);
 
-        if (sAppVersion == null) {
+        // Guarded per value: overrideAppVersion is documented to run before this constructor, and
+        // must not stop the build number from being read (and vice versa).
+        if (sAppVersion == null || sBuildNumber == null) {
             try {
                 PackageInfo pInfo = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
-                sAppVersion = pInfo.versionName;
-                sBuildNumber = String.valueOf(pInfo.versionCode);
+                if (sAppVersion == null) sAppVersion = pInfo.versionName;
+                if (sBuildNumber == null) sBuildNumber = String.valueOf(getVersionCode(pInfo));
             } catch (PackageManager.NameNotFoundException e) {
                 throw new CodePushUnknownException("Unable to get package info for " + mContext.getPackageName(), e);
             }
@@ -127,6 +130,14 @@ public class CodePush implements ReactPackage {
         mServerUrl = serverUrl;
     }
 
+    // versionCode is only the low half of the version code once versionCodeMajor is set.
+    private static long getVersionCode(PackageInfo packageInfo) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            return packageInfo.getLongVersionCode();
+        }
+        return packageInfo.versionCode;
+    }
+
     private String getPublicKeyByResourceDescriptor(int publicKeyResourceDescriptor) {
         String publicKey;
         try {

package/android/src/main/java/com/microsoft/codepush/react/CodePushConstants.java

@@ -18,6 +18,8 @@ public class CodePushConstants {
     public static final String ASSET_DOWNLOAD_URL_KEY = "assetDownloadUrl";
     public static final String BUNDLE_DOWNLOAD_URL_KEY = "bundleBlobUrl";
     public static final String BUNDLE_DIFF_DOWNLOAD_URL_KEY = "bundleDiffBlobUrl";
+    public static final String BASE_PACKAGE_KEY = "basePackage";
+    public static final String BASES_FOLDER_NAME = "bases";
 
     public static final String FAILED_UPDATES_KEY = "CODE_PUSH_FAILED_UPDATES";
     public static final String PACKAGE_FILE_NAME = BundleManager.PACKAGE_FILE_NAME;

package/android/src/main/java/com/microsoft/codepush/react/CodePushNativeModule.java

@@ -5,15 +5,15 @@ import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.Looper;
-import android.view.View;
 import android.view.Choreographer;
+import android.view.View;
+import android.view.ViewGroup;
 
 import androidx.annotation.OptIn;
 
 import com.facebook.react.ReactApplication;
 import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceManager;
-import com.facebook.react.ReactRootView;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.BaseJavaModule;
 import com.facebook.react.bridge.JSBundleLoader;
@@ -43,7 +43,6 @@ import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
@@ -58,6 +57,7 @@ public class CodePushNativeModule extends BaseJavaModule {
     private SettingsManager mSettingsManager;
     private CodePushTelemetryManager mTelemetryManager;
     private CodePushUpdateManager mUpdateManager;
+    private boolean mIsExpoApp = false;
 
     private boolean _allowed = true;
     private boolean _restartInProgress = false;
@@ -70,6 +70,8 @@ public class CodePushNativeModule extends BaseJavaModule {
         mSettingsManager = settingsManager;
         mTelemetryManager = codePushTelemetryManager;
         mUpdateManager = codePushUpdateManager;
+        mIsExpoApp = detectExpoEnvironment();
+
         // Initialize module state while we have a reference to the current context.
 
         mNativeBundleHash = bundleMetadataManager.getNativeBundleHash();
@@ -119,6 +121,31 @@ public class CodePushNativeModule extends BaseJavaModule {
         });
     }
 
+    private boolean detectExpoEnvironment() {
+        try {
+            Class.forName("expo.modules.ReactNativeHostWrapper", false, getClass().getClassLoader());
+            return true;
+        } catch (Throwable e) {
+            return false;
+        }
+    }
+
+    private Field findField(Class<?> clazz, String... fieldNames) throws NoSuchFieldException {
+        Class<?> currentClass = clazz;
+        while (currentClass != null) {
+            for (String fieldName : fieldNames) {
+                try {
+                    return currentClass.getDeclaredField(fieldName);
+                } catch (NoSuchFieldException ignored) {
+                }
+            }
+
+            currentClass = currentClass.getSuperclass();
+        }
+
+        throw new NoSuchFieldException(fieldNames.length > 0 ? fieldNames[0] : "");
+    }
+
     // Use reflection to find and set the appropriate fields on ReactInstanceManager. See #556 for a proposal for a less brittle way
     // to approach this.
     private void setJSBundle(ReactInstanceManager instanceManager, String latestJSBundleFile) throws IllegalAccessException {
@@ -130,7 +157,7 @@ public class CodePushNativeModule extends BaseJavaModule {
                 latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile);
             }
 
-            Field bundleLoaderField = instanceManager.getClass().getDeclaredField("mBundleLoader");
+            Field bundleLoaderField = findField(instanceManager.getClass(), "mBundleLoader");
             bundleLoaderField.setAccessible(true);
             bundleLoaderField.set(instanceManager, latestJSBundleLoader);
         } catch (Exception e) {
@@ -150,12 +177,10 @@ public class CodePushNativeModule extends BaseJavaModule {
                 latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile);
             }
 
-            Field bundleLoaderField = reactHostDelegate.getClass().getDeclaredField("jsBundleLoader");
+            Field bundleLoaderField = findField(reactHostDelegate.getClass(), "jsBundleLoader", "_jsBundleLoader");
             bundleLoaderField.setAccessible(true);
             bundleLoaderField.set(reactHostDelegate, latestJSBundleLoader);
-        } catch (NoSuchFieldException noSuchFileFound) {
-            // Ignore this error for Expo
-        } catch (Exception e) {
+        }  catch (Exception e) {
             CodePushUtils.log("Unable to set JSBundle of ReactHostDelegate - CodePush may not support this version of React Native");
             throw new IllegalAccessException("Could not setJSBundle");
         }
@@ -200,7 +225,9 @@ public class CodePushNativeModule extends BaseJavaModule {
                         }
                     }
                 } catch (Exception e) {
-                    CodePushUtils.log("Exception setJSBundle: " + e.getMessage());
+                    if (!mIsExpoApp) {
+                        CodePushUtils.log("Exception setJSBundle: " + e.getMessage());
+                    }
                 }
 
                 // #3) Get the context creation method
@@ -301,14 +328,38 @@ public class CodePushNativeModule extends BaseJavaModule {
     // resetReactRootViews allows to call recreateReactContextInBackground without any exceptions
     // This fix also relates to https://github.com/microsoft/react-native-code-push/issues/878
     private void resetReactRootViews(ReactInstanceManager instanceManager) throws NoSuchFieldException, IllegalAccessException {
-        Field mAttachedRootViewsField = instanceManager.getClass().getDeclaredField("mAttachedRootViews");
-        mAttachedRootViewsField.setAccessible(true);
-        List<ReactRootView> mAttachedRootViews = (List<ReactRootView>) mAttachedRootViewsField.get(instanceManager);
-        for (ReactRootView reactRootView : mAttachedRootViews) {
-            reactRootView.removeAllViews();
-            reactRootView.setId(View.NO_ID);
+        Field attachedRootsField = findField(instanceManager.getClass(), "mAttachedReactRoots", "mAttachedRootViews");
+        attachedRootsField.setAccessible(true);
+        Object attachedRoots = attachedRootsField.get(instanceManager);
+        if (attachedRoots instanceof Iterable) {
+            for (Object reactRoot : (Iterable<?>) attachedRoots) {
+                resetReactRootView(reactRoot);
+            }
+        }
+    }
+
+    private void resetReactRootView(Object reactRoot) {
+        try {
+            View rootView = null;
+            if (reactRoot instanceof View) {
+                rootView = (View) reactRoot;
+            } else {
+                Method getRootViewGroupMethod = reactRoot.getClass().getMethod("getRootViewGroup");
+                Object rootViewGroup = getRootViewGroupMethod.invoke(reactRoot);
+                if (rootViewGroup instanceof View) {
+                    rootView = (View) rootViewGroup;
+                }
+            }
+
+            if (rootView instanceof ViewGroup) {
+                ((ViewGroup) rootView).removeAllViews();
+            }
+            if (rootView != null) {
+                rootView.setId(View.NO_ID);
+            }
+        } catch (Exception e) {
+            CodePushUtils.log("Failed to reset root view: " + e.getMessage());
         }
-        mAttachedRootViewsField.set(instanceManager, mAttachedRootViews);
     }
 
     private void clearLifecycleEventListener() {
@@ -690,7 +741,12 @@ public class CodePushNativeModule extends BaseJavaModule {
                                         if (installMode == CodePushInstallMode.IMMEDIATE.getValue()
                                                 || durationInBackground >= CodePushNativeModule.this.mMinimumBackgroundDuration) {
                                             CodePushUtils.log("Loading bundle on resume");
-                                            restartAppInternal(false);
+                                            new Handler(Looper.getMainLooper()).post(new Runnable() {
+                                                @Override
+                                                public void run() {
+                                                    restartAppInternal(false);
+                                                }
+                                            });
                                         }
                                     }
                                 }
@@ -856,7 +912,7 @@ public class CodePushNativeModule extends BaseJavaModule {
                 field = clazz.getDeclaredField("mReactHostDelegate");
             } catch (NoSuchFieldException e) {
                 // RN >= 0.81
-                field = clazz.getDeclaredField("reactHostDelegate");
+                field = findField(reactHostImpl.getClass(), "mReactHostDelegate", "reactHostDelegate");
             }
             field.setAccessible(true);