@appzung/react-native-code-push 10.2.4 → 11.0.0-rc10

package/CodePush.podspec

@@ -14,14 +14,12 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = '15.5'
   s.preserve_paths = '*.js'
   s.library        = 'z'
-  s.source_files = 'ios/CodePush/*.{h,m}'
+  s.source_files = 'ios/CodePush/*.{h,m,mm}'
   s.public_header_files = ['ios/CodePush/CodePush.h']
   s.pod_target_xcconfig = { "DEFINES_MODULE" => "YES" }
 
-  # Note: Even though there are copy/pasted versions of some of these dependencies in the repo,
-  # we explicitly let CocoaPods pull in the versions below so all dependencies are resolved and
-  # linked properly at a parent workspace level.
-  s.dependency 'React-Core'
+  install_modules_dependencies(s)
+
   s.dependency 'SSZipArchive', '~> 2.5.5'
   s.dependency 'JWT', '~> 3.0.0-beta.12'
   s.dependency 'Base64', '~> 1.1'

package/README.md

@@ -55,13 +55,13 @@ Otherwise:
 npm install --save @appzung/react-native-code-push
 ```
 
-_NOTE: For Expo apps a plugin will be made available soon. In the meantime, you may eject._
-
 Then continue with installing the native module:
 
-- [iOS Setup](docs/setup-ios.md)
-- [Android Setup](docs/setup-android.md)
-- [Windows Setup](docs/setup-windows.md)
+- [iOS setup](docs/setup-ios.md)
+- [Android setup](docs/setup-android.md)
+- [Windows setup](docs/setup-windows.md)
+
+Or if your app is managed by the Expo framework, install and configure [@appzung/expo-config-code-push](https://github.com/AppZung/expo-config-code-push).
 
 ## Migrating to AppZung CodePush
 
@@ -109,8 +109,9 @@ We try our best to maintain backwards compatibility of our plugin with previous
 | v0.60-v0.61             | 4.1+ (TLS 1.2+) | 7    | ✅       | ❌       | v6.3.1                         |
 | v0.62-v0.64             | 4.1+ (TLS 1.2+) | 7    | ✅       | ❌       | v6.4.2                         |
 | v0.65-v0.70             | 4.1+ (TLS 1.2+) | 9    | ✅       | ❌       | v7.1.1                         |
-| v0.71+                  | 4.1+ (TLS 1.2+) | 9    | ✅       | ❌       | v8.3.2                         |
-| v0.71+                  | 4.1+ (TLS 1.2+) | 15.5 | ✅       | ❌       | v9.0.2 or v10+                 |
+| v0.71-v0.79             | 4.1+ (TLS 1.2+) | 9    | ✅       | ❌       | v8.3.2                         |
+| v0.71-v0.79             | 4.1+ (TLS 1.2+) | 15.5 | ✅       | ❌       | v9.0.2                         |
+| v0.71+                  | 4.1+ (TLS 1.2+) | 15.5 | ✅       | ❌       | v10+                           |
 | v0.74+                  | 4.1+ (TLS 1.2+) | 15.5 | ✅       | ✅       | v11+                           |
 
 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.
@@ -145,11 +146,11 @@ withCodePush({ checkFrequency: CheckFrequency.ON_APP_RESUME })(MyApp);
 Alternatively, if you want fine-grained control over when the check happens (like a button press or timer interval), eg. in a staging environment, you can call [`CodePush.sync()`](docs/api-js/functions/sync.md) at any time with your desired `SyncOptions`, and turn off CodePush's automatic checking by specifying a manual `checkFrequency`:
 
 ```javascript
-import withCodePush, { CheckFrequency, InstallMode } from '@appzung/react-native-code-push';
+import withCodePush, { CheckFrequency, InstallMode, sync } from '@appzung/react-native-code-push';
 
 class MyApp extends Component {
   onButtonPress() {
-    CodePush.sync({
+    sync({
       updateDialog: true,
       installMode: InstallMode.IMMEDIATE,
     });
@@ -173,7 +174,7 @@ If you would like to display an update confirmation dialog (an "active install")
 
 ## Releasing updates
 
-Once your app is configured and distributed to your users, and you have made some JS or asset changes, it's time to release them. The recommended way to release them is using the `appzung releases deploy-react-native` command in the AppZung CLI, which will bundle your JavaScript files, asset files, and release the update to the CodePush server.
+Once your app is configured and distributed to your users, and you have made some JS or asset changes, it's time to release them. The recommended way to release them is running the `appzung releases deploy-react-native` command (or `appzung releases deploy-expo` if using Expo) in the AppZung CLI, which will bundle your JavaScript files, asset files, and release the update to the CodePush server.
 
 ### Locally
 
@@ -258,7 +259,7 @@ This is not necessarily the case for `updateDialog`, since it won't force the us
 
 ## Debugging / Troubleshooting
 
-The `sync` method includes a lot of diagnostic logging out-of-the-box, so if you're encountering an issue when using it, the best thing to try first is examining the output logs of your app. This will tell you whether the app is configured correctly (like can the plugin find your release channel public ID?), if the app is able to reach the server, if an available update is being discovered, if the update is being successfully downloaded/installed, etc. We want to continue improving the logging to be as intuitive/comprehensive as possible, so please [let us know](mailto:support@appzung.com) if you find it to be confusing or missing anything.
+The `withCodePush`/`sync` methods include a lot of diagnostic logging out-of-the-box, so if you're encountering an issue when using it, the best thing to try first is examining the output logs of your app. This will tell you whether the app is configured correctly (like can the plugin find your release channel public ID?), if the app is able to reach the server, if an available update is being discovered, if the update is being successfully downloaded/installed, etc. We want to continue improving the logging to be as intuitive/comprehensive as possible, so please [let us know](mailto:support@appzung.com) if you find it to be confusing or missing anything.
 
 Start up the Chrome DevTools Console, the Xcode Console (iOS) and/or ADB logcat (Android), and look for messages which are prefixed with `[CodePush]`.
 
@@ -274,12 +275,13 @@ Note that by default, React Native logs are disabled on iOS in release builds, s
 
 Now you'll be able to see CodePush logs in either debug or release mode, on both iOS or Android. If examining the logs don't provide an indication of the issue, please refer to the following common issues for additional resolution ideas:
 
-| Issue / Symptom                                                                          | Possible Solution                                                                                                                                                                                                                                                                                                  |
-| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Compilation Error                                                                        | Clean your build folders and double-check that your version of React Native is [compatible](#compatibility-table) with the CodePush version you are using.                                                                                                                                                         |
-| Network timeout / hang when calling `sync` or `checkForUpdate` in the iOS Simulator      | Try resetting the simulator by selecting the `Simulator -> Reset Content and Settings..` menu item, and then re-running your app.                                                                                                                                                                                  |
-| Server responds with a `404` when calling `sync` or `checkForUpdate`                     | Double-check that the release channel public ID you added to your `Info.plist` (iOS), `strings.xml` or `app/build.gradle` (Android) or that you're passing to `sync`/`checkForUpdate`, is in fact correct. You can run `appzung release-channels list` to view the correct public ID for your app release channel. |
-| Update not being discovered                                                              | Double-check that the version of your running app (like `1.0.0`) matches the version you specified when releasing the update to CodePush. Additionally, make sure that you are releasing to the same release channel that your app is configured to sync with.                                                     |
-| Update not being displayed after restart                                                 | If you're not using the withCodePush HOC or calling `sync` on app start (like within `componentDidMount` of your root component), then you need to explicitly call `notifyAppReady` on app start, otherwise, the plugin will think your update failed and roll it back.                                            |
-| I've released an update for iOS but my Android app also shows an update and it breaks it | Be sure you have different release channels for each platform in order to receive updates correctly                                                                                                                                                                                                                |
-| I've released new update but changes are not reflected                                   | Be sure that you are running app in modes other than Debug. In Debug mode, React Native app always downloads JS bundle generated by packager, so JS bundle downloaded by CodePush does not apply.                                                                                                                  |
+| Issue / Symptom                                                                                                                                                                                                             | Possible Solution                                                                                                                                                                                                                                                                                                  |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Compilation Error                                                                                                                                                                                                           | Clean your build folders and double-check that your version of React Native is [compatible](#compatibility-table) with the CodePush version you are using.                                                                                                                                                         |
+| Network timeout / hang when calling `sync` or `checkForUpdate` in the iOS Simulator                                                                                                                                         | Try resetting the simulator by selecting the `Simulator -> Reset Content and Settings..` menu item, and then re-running your app.                                                                                                                                                                                  |
+| Server responds with a `404` when calling `sync` or `checkForUpdate`                                                                                                                                                        | Double-check that the release channel public ID you added to your `Info.plist` (iOS), `strings.xml` or `app/build.gradle` (Android) or that you're passing to `sync`/`checkForUpdate`, is in fact correct. You can run `appzung release-channels list` to view the correct public ID for your app release channel. |
+| Update not being discovered                                                                                                                                                                                                 | Double-check that the version of your running app (like `1.0.0`) matches the version you specified when releasing the update to CodePush. Additionally, make sure that you are releasing to the same release channel that your app is configured to sync with.                                                     |
+| Update not being displayed after restart                                                                                                                                                                                    | If you're not using the withCodePush HOC or calling `sync` on app start (like within `componentDidMount` of your root component), then you need to explicitly call `notifyAppReady` on app start, otherwise, the plugin will think your update failed and roll it back.                                            |
+| I've released an update for iOS but my Android app also shows an update and it breaks it                                                                                                                                    | Be sure you have different release channels for each platform in order to receive updates correctly                                                                                                                                                                                                                |
+| I've released new update but changes are not reflected                                                                                                                                                                      | Be sure that you are running app in modes other than Debug. In Debug mode, React Native app always downloads JS bundle generated by packager, so JS bundle downloaded by CodePush does not apply.                                                                                                                  |
+| Android compilation fails after migrating to AppZung with error "Task :app:checkReleaseAarMetadata FAILED A problem was found with the configuration of task ':app:checkReleaseAarMetadata' (type 'CheckAarMetadataTask')". | In `android/settings.gradle` remove the lines about CodePush. Be sure to read the other [migration steps](./docs/migrating-to-v10.md) carefully to review if you missed any others.                                                                                                                                |

package/android/app/build.gradle

@@ -1,5 +1,13 @@
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
 apply plugin: "com.android.library"
 
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["CodePush_" + name]
 }
@@ -33,6 +41,7 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
 
     consumerProguardFiles 'proguard-rules.pro'
   }

package/android/app/proguard-rules.pro

@@ -20,6 +20,11 @@
 -keepclassmembers class com.facebook.react.ReactInstanceManager {
     private final ** mBundleLoader;
 }
+-keepclassmembers class com.facebook.react.runtime.ReactHostImpl {
+    private final ** mReactHostDelegate;
+}
+-keep interface com.facebook.react.runtime.ReactHostDelegate { *; }
+-keep class * implements com.facebook.react.runtime.ReactHostDelegate { *; }
 
 # Can't find referenced class org.bouncycastle.**
 -dontwarn com.nimbusds.jose.**

package/android/app/src/main/java/com/appzung/codepush/react/CodePush.java

@@ -4,6 +4,7 @@ import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 
+import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceManager;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
@@ -18,6 +19,19 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class CodePush implements ReactPackage {
+    private static final Object LOCK = new Object();
+    private static volatile CodePush mCurrentInstance;
+
+    public static CodePush getInstance(Context context) {
+        if (mCurrentInstance == null) {
+            synchronized (LOCK) {
+                if (mCurrentInstance == null) {
+                    mCurrentInstance = new CodePush(context);
+                }
+            }
+        }
+        return mCurrentInstance;
+    }
 
     private static boolean sIsRunningBinaryVersion = false;
     private static boolean sNeedToReportRollback = false;
@@ -43,13 +57,14 @@ public class CodePush implements ReactPackage {
     private static String mPublicKey;
 
     private static ReactInstanceHolder mReactInstanceHolder;
-    private static CodePush mCurrentInstance;
+
+    private static ReactHostHolder mReactHostHolder;
 
     public static String getServiceUrl() {
         return mServerUrl;
     }
 
-    public CodePush(Context context) {
+    private CodePush(Context context) {
         mContext = context.getApplicationContext();
 
         String releaseChannelPublicIdFromStrings = getCustomPropertyFromStringsIfExist("ReleaseChannelPublicId");
@@ -188,6 +203,7 @@ public class CodePush implements ReactPackage {
 
     public static String getJSBundleFile(String assetsBundleFileName) {
         if (mCurrentInstance == null) {
+            CodePushUtils.log("A CodePush instance has not been created yet. Have you added it to your app's list of ReactPackages?");
             throw new CodePushNotInitializedException("A CodePush instance has not been created yet. Have you added it to your app's list of ReactPackages?");
         }
 
@@ -366,6 +382,18 @@ public class CodePush implements ReactPackage {
         return mReactInstanceHolder.getReactInstanceManager();
     }
 
+    public static void setReactHost(ReactHostHolder reactHostHolder) {
+        mReactHostHolder = reactHostHolder;
+    }
+
+    static ReactHost getReactHost() {
+        if (mReactHostHolder == null) {
+            return null;
+        }
+
+        return mReactHostHolder.getReactHost();
+    }
+
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
         CodePushNativeModule codePushModule = new CodePushNativeModule(reactApplicationContext, this, mUpdateManager, mTelemetryManager, mSettingsManager);

package/android/app/src/main/java/com/appzung/codepush/react/CodePushNativeModule.java

@@ -8,22 +8,28 @@ import android.os.Looper;
 import android.view.Choreographer;
 import android.view.View;
 
+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;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.modules.debug.interfaces.DeveloperSettings;
+import com.facebook.react.runtime.ReactHostDelegate;
+import com.facebook.react.runtime.ReactHostImpl;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -39,11 +45,13 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-public class CodePushNativeModule extends ReactContextBaseJavaModule {
+@OptIn(markerClass = UnstableReactNativeAPI.class)
+public class CodePushNativeModule extends BaseJavaModule {
     private String mBinaryContentsHash = null;
     private String mClientUniqueId = null;
     private boolean mTelemetryEnabled = true;
     private boolean mDataTransmissionEnabled = true;
+    private boolean mIsExpoApp = false;
     private LifecycleEventListener mLifecycleEventListener = null;
     private int mMinimumBackgroundDuration = 0;
 
@@ -52,9 +60,9 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     private CodePushTelemetryManager mTelemetryManager;
     private CodePushUpdateManager mUpdateManager;
 
-    private  boolean _allowed = true;
-    private  boolean _restartInProgress = false;
-    private  ArrayList<Boolean> _restartQueue = new ArrayList<>();
+    private boolean _allowed = true;
+    private boolean _restartInProgress = false;
+    private ArrayList<Boolean> _restartQueue = new ArrayList<>();
 
     public CodePushNativeModule(ReactApplicationContext reactContext, CodePush codePush, CodePushUpdateManager codePushUpdateManager, CodePushTelemetryManager codePushTelemetryManager, SettingsManager settingsManager) {
         super(reactContext);
@@ -64,6 +72,8 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         mTelemetryManager = codePushTelemetryManager;
         mUpdateManager = codePushUpdateManager;
 
+        mIsExpoApp = ExpoUtils.detectExpoEnvironment(reactContext);
+
         // Initialize module state while we have a reference to the current context.
         mBinaryContentsHash = CodePushUpdateUtils.getHashForBinaryContents(reactContext, mCodePush.isDebugMode());
 
@@ -119,7 +129,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     private void loadBundleLegacy() {
-        final Activity currentActivity = getCurrentActivity();
+        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
         if (currentActivity == null) {
             // The currentActivity can be null if it is backgrounded / destroyed, so we simply
             // no-op to prevent any null pointer exceptions.
@@ -150,65 +160,135 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             bundleLoaderField.setAccessible(true);
             bundleLoaderField.set(instanceManager, latestJSBundleLoader);
         } catch (Exception e) {
-            CodePushUtils.log("Unable to set JSBundle - CodePush may not support this version of React Native");
+            CodePushUtils.log("Unable to set JSBundle of ReactInstanceManager - CodePush may not support this version of React Native");
             throw new IllegalAccessException("Could not setJSBundle");
         }
     }
 
-    private void loadBundle() {
-        clearLifecycleEventListener();
+    // Use reflection to find and set the appropriate fields on ReactHostDelegate. See #556 for a proposal for a less brittle way
+    // to approach this.
+    private void setJSBundle(ReactHostDelegate reactHostDelegate, String latestJSBundleFile) throws IllegalAccessException {
         try {
-            DevSupportManager devSupportManager = null;
-            ReactInstanceManager reactInstanceManager = resolveInstanceManager();
-            if (reactInstanceManager != null) {
-                devSupportManager = reactInstanceManager.getDevSupportManager();
+            JSBundleLoader latestJSBundleLoader;
+            if (latestJSBundleFile.toLowerCase().startsWith("assets://")) {
+                latestJSBundleLoader = JSBundleLoader.createAssetLoader(getReactApplicationContext(), latestJSBundleFile, false);
+            } else {
+                latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile);
             }
-            boolean isLiveReloadEnabled = isLiveReloadEnabled(devSupportManager);
 
-            mCodePush.clearDebugCacheIfNeeded(isLiveReloadEnabled);
-        } catch(Exception e) {
-            // If we got error in out reflection we should clear debug cache anyway.
-            mCodePush.clearDebugCacheIfNeeded(false);
+            Field bundleLoaderField = reactHostDelegate.getClass().getDeclaredField("jsBundleLoader");
+            bundleLoaderField.setAccessible(true);
+            bundleLoaderField.set(reactHostDelegate, latestJSBundleLoader);
+        } 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");
         }
+    }
 
-        try {
-            // #1) Get the ReactInstanceManager instance, which is what includes the
-            //     logic to reload the current React context.
-            final ReactInstanceManager instanceManager = resolveInstanceManager();
-            if (instanceManager == null) {
-                return;
+    private void loadBundle() {
+        clearLifecycleEventListener();
+
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            try {
+                DevSupportManager devSupportManager = null;
+                ReactHost reactHost = resolveReactHost();
+                if (reactHost != null) {
+                    devSupportManager = reactHost.getDevSupportManager();
+                }
+                boolean isLiveReloadEnabled = isLiveReloadEnabled(devSupportManager);
+
+                mCodePush.clearDebugCacheIfNeeded(isLiveReloadEnabled);
+            } catch (Exception e) {
+                // If we got error in out reflection we should clear debug cache anyway.
+                mCodePush.clearDebugCacheIfNeeded(false);
             }
 
-            String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
-
-            // #2) Update the locally stored JS bundle file path
-            setJSBundle(instanceManager, latestJSBundleFile);
-
-            // #3) Get the context creation method and fire it on the UI thread (which RN enforces)
-            new Handler(Looper.getMainLooper()).post(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        // We don't need to resetReactRootViews anymore
-                        // due the issue https://github.com/facebook/react-native/issues/14533
-                        // has been fixed in RN 0.46.0
-                        //resetReactRootViews(instanceManager);
-
-                        instanceManager.recreateReactContextInBackground();
-                        mCodePush.initializeUpdateAfterRestart();
-                    } catch (Exception e) {
-                        // The recreation method threw an unknown exception
-                        // so just simply fallback to restarting the Activity (if it exists)
-                        loadBundleLegacy();
-                    }
+            try {
+                // #1) Get the ReactHost instance, which is what includes the
+                //     logic to reload the current React context.
+                final ReactHost reactHost = resolveReactHost();
+                if (reactHost == null) {
+                    return;
                 }
-            });
 
-        } catch (Exception e) {
-            // Our reflection logic failed somewhere
-            // so fall back to restarting the Activity (if it exists)
-            CodePushUtils.log("Failed to load the bundle, falling back to restarting the Activity (if it exists). " + e.getMessage());
-            loadBundleLegacy();
+                String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
+
+                // if expo and new arch this is unnecessary, see https://github.com/expo/expo/blob/8113ce44edaef0311e2daff3ab1a63b9731d2d6c/packages/expo-updates/android/src/main/java/expo/modules/updates/procedures/RelaunchProcedure.kt#L148
+                if (!mIsExpoApp) {
+                    // #2) Update the locally stored JS bundle file path
+                    setJSBundle(getReactHostDelegate((ReactHostImpl) reactHost), latestJSBundleFile);
+                }
+
+                // #3) Get the context creation method
+                try {
+                    reactHost.reload("CodePush triggers reload");
+                    mCodePush.initializeUpdateAfterRestart();
+                } catch (Exception e) {
+                    // The recreation method threw an unknown exception
+                    // so just simply fallback to restarting the Activity (if it exists)
+                    loadBundleLegacy();
+                }
+
+            } catch (Exception e) {
+                // Our reflection logic failed somewhere
+                // so fall back to restarting the Activity (if it exists)
+                CodePushUtils.log("Failed to load the bundle, falling back to restarting the Activity (if it exists). " + e.getMessage());
+                loadBundleLegacy();
+            }
+        } else {
+            try {
+                DevSupportManager devSupportManager = null;
+                ReactInstanceManager reactInstanceManager = resolveInstanceManager();
+                if (reactInstanceManager != null) {
+                    devSupportManager = reactInstanceManager.getDevSupportManager();
+                }
+                boolean isLiveReloadEnabled = isLiveReloadEnabled(devSupportManager);
+
+                mCodePush.clearDebugCacheIfNeeded(isLiveReloadEnabled);
+            } catch (Exception e) {
+                // If we got error in out reflection we should clear debug cache anyway.
+                mCodePush.clearDebugCacheIfNeeded(false);
+            }
+
+            try {
+                // #1) Get the ReactInstanceManager instance, which is what includes the
+                //     logic to reload the current React context.
+                final ReactInstanceManager instanceManager = resolveInstanceManager();
+                if (instanceManager == null) {
+                    return;
+                }
+
+                String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
+
+                // #2) Update the locally stored JS bundle file path
+                setJSBundle(instanceManager, latestJSBundleFile);
+
+                // #3) Get the context creation method and fire it on the UI thread (which RN enforces)
+                new Handler(Looper.getMainLooper()).post(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            // We don't need to resetReactRootViews anymore
+                            // due the issue https://github.com/facebook/react-native/issues/14533
+                            // has been fixed in RN 0.46.0
+                            //resetReactRootViews(instanceManager);
+
+                            instanceManager.recreateReactContextInBackground();
+                            mCodePush.initializeUpdateAfterRestart();
+                        } catch (Exception e) {
+                            // The recreation method threw an unknown exception
+                            // so just simply fallback to restarting the Activity (if it exists)
+                            loadBundleLegacy();
+                        }
+                    }
+                });
+
+            } catch (Exception e) {
+                // Our reflection logic failed somewhere
+                // so fall back to restarting the Activity (if it exists)
+                CodePushUtils.log("Failed to load the bundle, falling back to restarting the Activity (if it exists). " + e.getMessage());
+                loadBundleLegacy();
+            }
         }
     }
 
@@ -238,7 +318,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     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);
+        List<ReactRootView> mAttachedRootViews = (List<ReactRootView>) mAttachedRootViewsField.get(instanceManager);
         for (ReactRootView reactRootView : mAttachedRootViews) {
             reactRootView.removeAllViews();
             reactRootView.setId(View.NO_ID);
@@ -261,7 +341,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             return instanceManager;
         }
 
-        final Activity currentActivity = getCurrentActivity();
+        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
         if (currentActivity == null) {
             return null;
         }
@@ -272,6 +352,21 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         return instanceManager;
     }
 
+    private ReactHost resolveReactHost() throws NoSuchFieldException, IllegalAccessException {
+        ReactHost reactHost = CodePush.getReactHost();
+        if (reactHost != null) {
+            return reactHost;
+        }
+
+        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+        if (currentActivity == null) {
+            return null;
+        }
+
+        ReactApplication reactApplication = (ReactApplication) currentActivity.getApplication();
+        return reactApplication.getReactHost();
+    }
+
     private void restartAppInternal(boolean onlyIfUpdateIsPending) {
         if (this._restartInProgress) {
             CodePushUtils.log("Restart request queued until the current restart is completed");
@@ -334,7 +429,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         try {
             restartAppInternal(onlyIfUpdateIsPending);
             promise.resolve(null);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
@@ -415,7 +510,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getConfiguration(Promise promise) {
         try {
-            WritableMap configMap =  Arguments.createMap();
+            WritableMap configMap = Arguments.createMap();
             configMap.putString("appVersion", mCodePush.getAppVersion());
             configMap.putString("clientUniqueId", mClientUniqueId);
             configMap.putString("releaseChannelPublicId", mCodePush.getReleaseChannelPublicId());
@@ -429,7 +524,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             }
 
             promise.resolve(configMap);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
@@ -491,7 +586,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     CodePushUtils.log(e.getMessage());
                     clearUpdates();
                     promise.resolve(null);
-                } catch(CodePushUnknownException e) {
+                } catch (CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
@@ -549,7 +644,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     }
 
                     promise.resolve("");
-                } catch(CodePushUnknownException e) {
+                } catch (CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
@@ -576,11 +671,11 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     }
 
                     if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue() ||
-                        // We also add the resume listener if the installMode is IMMEDIATE, because
-                        // if the current activity is backgrounded, we want to reload the bundle when
-                        // it comes back into the foreground.
-                        installMode == CodePushInstallMode.IMMEDIATE.getValue() ||
-                        installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
+                            // We also add the resume listener if the installMode is IMMEDIATE, because
+                            // if the current activity is backgrounded, we want to reload the bundle when
+                            // it comes back into the foreground.
+                            installMode == CodePushInstallMode.IMMEDIATE.getValue() ||
+                            installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
 
                         // Store the minimum duration on the native module as an instance
                         // variable instead of relying on a closure below, so that any
@@ -636,7 +731,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     }
 
                     promise.resolve("");
-                } catch(CodePushUnknownException e) {
+                } catch (CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
@@ -692,7 +787,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     && packageHash.length() > 0
                     && packageHash.equals(mUpdateManager.getCurrentPackageHash());
             promise.resolve(isFirstRun);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
@@ -703,7 +798,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         try {
             mSettingsManager.removePendingUpdate();
             promise.resolve("");
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);
         }
@@ -713,7 +808,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     public void recordStatusReported(ReadableMap statusReport) {
         try {
             mTelemetryManager.recordStatusReported(statusReport);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
         }
     }
@@ -722,7 +817,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     public void saveStatusReportForRetry(ReadableMap statusReport) {
         try {
             mTelemetryManager.saveStatusReportForRetry(statusReport);
-        } catch(CodePushUnknownException e) {
+        } catch (CodePushUnknownException e) {
             CodePushUtils.log(e);
         }
     }
@@ -739,7 +834,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     throw new CodePushUnknownException("Unable to replace current bundle", e);
                 }
             }
-        } catch(CodePushUnknownException | CodePushMalformedDataException e) {
+        } catch (CodePushUnknownException | CodePushMalformedDataException e) {
             CodePushUtils.log(e);
         }
     }
@@ -816,4 +911,18 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     public void removeListeners(Integer count) {
         // Remove upstream listeners, stop unnecessary background tasks
     }
+
+    public ReactHostDelegate getReactHostDelegate(ReactHostImpl reactHostImpl) {
+        try {
+            Class<?> clazz = reactHostImpl.getClass();
+            Field field = clazz.getDeclaredField("mReactHostDelegate");
+            field.setAccessible(true);
+
+            // Get the value of the field for the provided instance
+            return (ReactHostDelegate) field.get(reactHostImpl);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
 }