@turbopush/react-native-code-push 9.0.2 → 10.2.3

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

@@ -5,24 +5,31 @@ import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.Looper;
-import android.provider.Settings;
 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.modules.core.ChoreographerCompat;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import android.view.Choreographer;
 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;
@@ -30,6 +37,7 @@ import org.json.JSONObject;
 
 import java.io.IOException;
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
@@ -37,7 +45,8 @@ 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 LifecycleEventListener mLifecycleEventListener = null;
@@ -93,7 +102,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.
@@ -124,61 +133,180 @@ 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 {
-            mCodePush.clearDebugCacheIfNeeded(resolveInstanceManager());
-        } catch(Exception e) {
-            // If we got error in out reflection we should clear debug cache anyway.
-            mCodePush.clearDebugCacheIfNeeded(null);
+            JSBundleLoader latestJSBundleLoader;
+            if (latestJSBundleFile.toLowerCase().startsWith("assets://")) {
+                latestJSBundleLoader = JSBundleLoader.createAssetLoader(getReactApplicationContext(), latestJSBundleFile, false);
+            } else {
+                latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile);
+            }
+
+            Field bundleLoaderField = reactHostDelegate.getClass().getDeclaredField("jsBundleLoader");
+            bundleLoaderField.setAccessible(true);
+            bundleLoaderField.set(reactHostDelegate, latestJSBundleLoader);
+
+        } catch (NoSuchFieldException nsfe) {
+            CodePushUtils.log("Field 'jsBundleLoader' NOT FOUND on " + (reactHostDelegate != null ? reactHostDelegate.getClass().getName() : "null") + ". This is an EXPECTED and IGNORED failure with ExpoReactHostDelegate. Will rely on reactHost.reload(). Original log: Unable to set JSBundle of ReactHostDelegate - CodePush may not support this version of React Native");
+            // DO NOT THROW for NoSuchFieldException.
+        }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();
+
+        // ReactNative core components are changed on new architecture.
+        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);
+            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) {
+                    loadBundleLegacy(); // Fallback if reactHost can't be resolved
+                    return;
+                }
 
-            // #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();
+                String latestJSBundleFile = mCodePush.getJSBundleFileInternal(mCodePush.getAssetsBundleFileName());
+                CodePushUtils.log("[MyDebug] Latest JS bundle for New Arch: " + latestJSBundleFile);
+
+     
+                try {
+                    if (reactHost instanceof ReactHostImpl) { 
+                        ReactHostDelegate delegate = getReactHostDelegate((ReactHostImpl) reactHost); 
+                        if (delegate != null) {
+                            // #2) Update the locally stored JS bundle file path
+                            setJSBundle(delegate, latestJSBundleFile); 
+                        } else {
+                            CodePushUtils.log("Could not get ReactHostDelegate from ReactHostImpl.");
+                        }
+                    } else {
+                        CodePushUtils.log("ReactHost is not a direct ReactHostImpl instance (" + reactHost.getClass().getName() + "), skipping direct setJSBundle reflection attempt. This is expected with Expo.");
                     }
+                } catch (ClassCastException cce) {
+                    CodePushUtils.log(new Exception("ClassCastException trying to get/use ReactHostDelegate. Skipping reflection call to setJSBundle. This is expected for Expo.", cce));
+                }catch (Exception e) {
+                    // Catch any unexpected errors from the attempt to call setJSBundle, e.g., if getReactHostDelegate itself fails
+                    CodePushUtils.log("Exception during the reflective setJSBundle block: " + e.getMessage());
                 }
-            });
 
-        } 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();
+                // #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) {
+                // 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();
+            }
+
         }
     }
 
+    private boolean isLiveReloadEnabled(DevSupportManager devSupportManager) {
+        if (devSupportManager != null) {
+            DeveloperSettings devSettings = devSupportManager.getDevSettings();
+            Method[] methods = devSettings.getClass().getMethods();
+            for (Method m : methods) {
+                if (m.getName().equals("isReloadOnJSChangeEnabled")) {
+                    try {
+                        return (boolean) m.invoke(devSettings);
+                    } catch (Exception x) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
     // This workaround has been implemented in order to fix https://github.com/facebook/react-native/issues/14533
     // resetReactRootViews allows to call recreateReactContextInBackground without any exceptions
     // This fix also relates to https://github.com/microsoft/react-native-code-push/issues/878
@@ -208,7 +336,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             return instanceManager;
         }
 
-        final Activity currentActivity = getCurrentActivity();
+        final Activity currentActivity = getReactApplicationContext().getCurrentActivity();
         if (currentActivity == null) {
             return null;
         }
@@ -219,6 +347,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");
@@ -320,7 +463,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                             getReactApplicationContext().runOnUiQueueThread(new Runnable() {
                                 @Override
                                 public void run() {
-                                    ReactChoreographer.getInstance().postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, new ChoreographerCompat.FrameCallback() {
+                                    ReactChoreographer.getInstance().postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, new Choreographer.FrameCallback() {
                                         @Override
                                         public void doFrame(long frameTimeNanos) {
                                             if (!latestDownloadProgress.isCompleted()) {
@@ -711,4 +854,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;
+        }
+    }
 }

package/android/app/src/main/java/com/microsoft/codepush/react/ReactHostHolder.java

@@ -0,0 +1,11 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.ReactHost;
+import com.facebook.react.runtime.ReactHostDelegate;
+
+/**
+ * Provides access to a {@link ReactHostDelegate}
+ */
+public interface ReactHostHolder {
+    ReactHost getReactHost();
+}

package/android/app/src/main/java/com/microsoft/codepush/react/ReactInstanceHolder.java

@@ -14,4 +14,7 @@ public interface ReactInstanceHolder {
    * Get the current {@link ReactInstanceManager} instance. May return null.
    */
   ReactInstanceManager getReactInstanceManager();
+
+
+
 }

package/android/codepush.gradle

@@ -69,9 +69,9 @@ gradle.projectsEvaluated {
 
         def nodeModulesPath;
         if (project.hasProperty('nodeModulesPath')) {
-            nodeModulesPath = "${project.nodeModulesPath}/react-native-code-push"
+            nodeModulesPath = "${project.nodeModulesPath}/@turbopush/react-native-code-push"
         } else {
-            nodeModulesPath = findNodeModulePath(projectDir, "react-native-code-push")
+            nodeModulesPath = findNodeModulePath(projectDir, "@turbopush/react-native-code-push")
         }
 
         def targetName = variant.name.capitalize()

package/docs/api-android.md

@@ -1,83 +1,52 @@
-### Java API Reference (Android)
-
-### API for React Native 0.60 version and above
+### Resource Configuration
 
 Since `autolinking` uses `react-native.config.js` to link plugins, constructors are specified in that file. But you can override custom variables to manage the CodePush plugin by placing these values in string resources.
 
-* __Public Key__ - used for bundle verification in the Code Signing Feature. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more details about the Code Signing Feature.
-    To set the public key, you should add the content of the public key to `strings.xml` with name `CodePushPublicKey`. CodePush automatically gets this property and enables the Code Signing feature. For example:
-    ```xml
-    <string moduleConfig="true" name="CodePushPublicKey">your-public-key</string>
-    ```
+- **Public Key** - used for bundle verification in the Code Signing Feature. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more details about the Code Signing Feature.
+  To set the public key, you should add the content of the public key to `strings.xml` with name `CodePushPublicKey`. CodePush automatically gets this property and enables the Code Signing feature. For example:
 
-* __Server Url__ - used for specifying CodePush Server Url.
-    The Default value: "https://codepush.appcenter.ms/" is overridden by adding your path to `strings.xml` with name `CodePushServerUrl`. CodePush automatically gets this property and will use this path to send requests. For example:
-    ```xml
-    <string moduleConfig="true" name="CodePushServerUrl">https://yourcodepush.server.com</string>
-    ```
+  ```xml
+  <string moduleConfig="true" name="CodePushPublicKey">your-public-key</string>
+  ```
 
-### API for React Native lower than 0.60
+- **Server Url** - used for specifying CodePush Server Url.
+  The Default value: "https://codepush.appcenter.ms/" is overridden by adding your path to `strings.xml` with name `CodePushServerUrl`. CodePush automatically gets this property and will use this path to send requests. For example:
+  ```xml
+  <string moduleConfig="true" name="CodePushServerUrl">https://yourcodepush.server.com</string>
+  ```
 
 The Java API is made available by importing the `com.microsoft.codepush.react.CodePush` class into your `MainActivity.java` file, and consists of a single public class named `CodePush`.
 
+### Java API Reference (Android)
+
 #### CodePush
 
 Constructs the CodePush client runtime and represents the `ReactPackage` instance that you add to you app's list of packages.
 
 ##### Constructors
 
-- __CodePush(String deploymentKey, Activity mainActivity)__ - Creates a new instance of the CodePush runtime, that will be used to query the service for updates via the provided deployment key. The `mainActivity` parameter should always be set to `this` when configuring your React packages list inside the `MainActivity` class. This constructor puts the CodePush runtime into "release mode", so if you want to enable debugging behavior, use the following constructor instead.
-
-- __CodePush(String deploymentKey, Activity mainActivity, bool isDebugMode)__ - Equivalent to the previous constructor but allows you to specify whether you want the CodePush runtime to be in debug mode or not. When using this constructor, the `isDebugMode` parameter should always be set to `BuildConfig.DEBUG` in order to stay synchronized with your build type. When putting CodePush into debug mode, the following behaviors are enabled:
-
-    1. Old CodePush updates aren't deleted from storage whenever a new binary is deployed to the emulator/device. This behavior enables you to deploy new binaries, without bumping the version during development, and without continuously getting the same update every time your app calls `sync`.
-
-    2. The local cache that the React Native runtime maintains in debug mode is deleted whenever a CodePush update is installed. This ensures that when the app is restarted after an update is applied, you will see the expected changes. As soon as [this PR](https://github.com/facebook/react-native/pull/4738) is merged, we won't need to do this anymore.
-
-- __CodePush(String deploymentKey, Context context, boolean isDebugMode, Integer publicKeyResourceDescriptor)__ - Equivalent to the previous constructor, but allows you to specify the public key resource descriptor needed to read public key content. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more details about the Code Signing Feature.
-
-- __CodePush(String deploymentKey, Context context, boolean isDebugMode, String serverUrl)__ Constructor allows you to specify CodePush Server Url. The Default value: `"https://codepush.appcenter.ms/"` is overridden by value specified in `serverUrl`.
-
-##### Builder
-
-As an alternative to constructors *you can also use `CodePushBuilder`* to setup a CodePush instance configured with *only parameters you want*.
-
-```java
-    @Override
-    protected List<ReactPackage> getPackages() {
-      return Arrays.<ReactPackage>asList(
-            new MainReactPackage(),
-            new CodePushBuilder("deployment-key-here",getApplicationContext())
-                .setIsDebugMode(BuildConfig.DEBUG)
-                .setPublicKeyResourceDescriptor(R.string.publicKey)
-                .setServerUrl("https://yourcodepush.server.com")
-                .build() //return configured CodePush instance
-      );
-    }
-```
-
-`CodePushBuilder` methods:
+- **CodePush(String deploymentKey, Activity mainActivity)** - Creates a new instance of the CodePush runtime, that will be used to query the service for updates via the provided deployment key. The `mainActivity` parameter should always be set to `this` when configuring your React packages list inside the `MainActivity` class. This constructor puts the CodePush runtime into "release mode", so if you want to enable debugging behavior, use the following constructor instead.
 
-* __public CodePushBuilder(String deploymentKey, Context context)__ - setup same parameters as via __CodePush(String deploymentKey, Activity mainActivity)__
+- **CodePush(String deploymentKey, Activity mainActivity, bool isDebugMode)** - Equivalent to the previous constructor but allows you to specify whether you want the CodePush runtime to be in debug mode or not. When using this constructor, the `isDebugMode` parameter should always be set to `BuildConfig.DEBUG` in order to stay synchronized with your build type. When putting CodePush into debug mode, the following behaviors are enabled:
 
-* __public CodePushBuilder setIsDebugMode(boolean isDebugMode)__ - allows you to specify whether you want the CodePush runtime to be in debug mode or not. Default value: `false`.
+  1. Old CodePush updates aren't deleted from storage whenever a new binary is deployed to the emulator/device. This behavior enables you to deploy new binaries, without bumping the version during development, and without continuously getting the same update every time your app calls `sync`.
 
-* __public CodePushBuilder setServerUrl(String serverUrl)__ - allows you to specify CodePush Server Url. Default value: `"https://codepush.appcenter.ms/"`.
+  2. The local cache that the React Native runtime maintains in debug mode is deleted whenever a CodePush update is installed. This ensures that when the app is restarted after an update is applied, you will see the expected changes. As soon as [this PR](https://github.com/facebook/react-native/pull/4738) is merged, we won't need to do this anymore.
 
-* __public CodePushBuilder setPublicKeyResourceDescriptor(int publicKeyResourceDescriptor)__ - allows you to specify Public Key resource descriptor which will be used for reading Public Key content for `strings.xml` file. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more detailed information about purpose of this parameter.
+- **CodePush(String deploymentKey, Context context, boolean isDebugMode, Integer publicKeyResourceDescriptor)** - Equivalent to the previous constructor, but allows you to specify the public key resource descriptor needed to read public key content. Please refer to [Code Signing](setup-android.md#code-signing-setup) section for more details about the Code Signing Feature.
 
-* __public CodePush build()__ - return configured `CodePush` instance.
+- **CodePush(String deploymentKey, Context context, boolean isDebugMode, String serverUrl)** Constructor allows you to specify CodePush Server Url. The Default value: `"https://codepush.appcenter.ms/"` is overridden by value specified in `serverUrl`.
 
 ##### Public Methods
 
-- __setDeploymentKey(String deploymentKey)__ - Sets the deployment key that the app should use when querying for updates. This is a dynamic alternative to setting the deployment key in Codepush constructor/builder and/or specifying a deployment key in JS when calling `checkForUpdate` or `sync`.
+- **setDeploymentKey(String deploymentKey)** - Sets the deployment key that the app should use when querying for updates. This is a dynamic alternative to setting the deployment key in Codepush constructor/builder and/or specifying a deployment key in JS when calling `checkForUpdate` or `sync`.
 
 ##### Static Methods
 
-- __getBundleUrl()__ - Returns the path to the most recent version of your app's JS bundle file, assuming that the resource name is `index.android.bundle`. If your app is using a different bundle name, then use the overloaded version of this method which allows specifying it. This method has the same resolution behavior as the Objective-C equivalent described above.
+- **getBundleUrl()** - Returns the path to the most recent version of your app's JS bundle file, assuming that the resource name is `index.android.bundle`. If your app is using a different bundle name, then use the overloaded version of this method which allows specifying it. This method has the same resolution behavior as the Objective-C equivalent described above.
 
-- __getBundleUrl(String bundleName)__ - Returns the path to the most recent version of your app's JS bundle file, using the specified resource name (like `index.android.bundle`). This method has the same resolution behavior as the Objective-C equivalent described above.
+- **getBundleUrl(String bundleName)** - Returns the path to the most recent version of your app's JS bundle file, using the specified resource name (like `index.android.bundle`). This method has the same resolution behavior as the Objective-C equivalent described above.
 
-- __getPackageFolder()__ - Returns the path to the current update folder.
+- **getPackageFolder()** - Returns the path to the current update folder.
 
-- __overrideAppVersion(String appVersionOverride)__ - Sets the version of the application's binary interface, which would otherwise default to the Play Store version specified as the `versionName` in the `build.gradle`. This should be called a single time, before the CodePush instance is constructed.
+- **overrideAppVersion(String appVersionOverride)** - Sets the version of the application's binary interface, which would otherwise default to the Play Store version specified as the `versionName` in the `build.gradle`. This should be called a single time, before the CodePush instance is constructed.

package/docs/multi-deployment-testing-android.md

@@ -10,7 +10,7 @@ The [Android Gradle plugin](https://google.github.io/android-gradle-dsl/current/
 
 To set this up, perform the following steps:
 
-**For React Native >= v0.60**
+**For React Native >= v0.76**
 
 1. Open the project's app level `build.gradle` file (for example `android/app/build.gradle` in standard React Native projects)
 
@@ -51,98 +51,5 @@ To set this up, perform the following steps:
 
     *NOTE: The naming convention for `releaseStaging` is significant due to [this line](https://github.com/facebook/react-native/blob/e083f9a139b3f8c5552528f8f8018529ef3193b9/react.gradle#L79).*
 
-**For React Native v0.29 - v0.59**
-
-1. Open up your `MainApplication.java` file and make the following changes:
-
-    ```java
-    @Override
-    protected List<ReactPackage> getPackages() {
-         return Arrays.<ReactPackage>asList(
-             ...
-             new CodePush(BuildConfig.CODEPUSH_KEY, MainApplication.this, BuildConfig.DEBUG), // Add/change this line.
-             ...
-         );
-    }
-    ```
-
-2. Open your app's `build.gradle` file (for example `android/app/build.gradle` in standard React Native projects)
-
-3. Find the `android { buildTypes {} }` section and define `buildConfigField` entries for both your `debug` and `release` build types, which reference your `Staging` and `Production` deployment keys respectively. If you prefer, you can define the key literals in your `gradle.properties` file, and then reference them here. Either way will work, and it's just a matter of personal preference.
-
-    ```groovy
-    android {
-        ...
-        buildTypes {
-            debug {
-                ...
-                // Note: CodePush updates should not be tested in Debug mode as they are overriden by the RN packager. However, because CodePush checks for updates in all modes, we must supply a key.
-                buildConfigField "String", "CODEPUSH_KEY", '""'
-                ...
-            }
-
-            releaseStaging {
-                ...
-                buildConfigField "String", "CODEPUSH_KEY", '"<INSERT_STAGING_KEY>"'
-                // Note: It is a good idea to provide matchingFallbacks for the new buildType you create to prevent build issues
-                // Add the following line if not already there
-                matchingFallbacks = ['release']
-                ...
-            }
-
-            release {
-                ...
-                buildConfigField "String", "CODEPUSH_KEY", '"<INSERT_PRODUCTION_KEY>"'
-                ...
-            }
-        }
-        ...
-    }
-    ```
-
-    *NOTE: The naming convention for `releaseStaging` is significant due to [this line](https://github.com/facebook/react-native/blob/e083f9a139b3f8c5552528f8f8018529ef3193b9/react.gradle#L79).*
-
-4. Pass the deployment key to the `CodePush` constructor via the build config you defined, as opposed to a string literal.
-
-**For React Native v0.19 - v0.28**
-
-Open up your `MainActivity.java` file and make the following changes:
-
- ```java
- @Override
- protected List<ReactPackage> getPackages() {
-     return Arrays.<ReactPackage>asList(
-         ...
-         new CodePush(BuildConfig.CODEPUSH_KEY, this, BuildConfig.DEBUG), // Add/change this line.
-         ...
-     );
- }
- ```
-
-*Note: If you gave your build setting a different name in your Gradle file, simply make sure to reflect that in your Java code.*
-
-And that's it! Now when you run or build your app, your debug builds will automatically be configured to sync with your `Staging` deployment, and your release builds will be configured to sync with your `Production` deployment.
-
-*NOTE: By default, the `react-native run-android` command builds and deploys the debug version of your app, so if you want to test out a release/production build, simply run `react-native run-android --variant release. Refer to the [React Native docs](http://facebook.github.io/react-native/docs/signed-apk-android.html#conten) for details about how to configure and create release builds for your Android apps.*
-
-If you want to be able to install both debug and release builds simultaneously on the same device (highly recommended!), then you need to ensure that your debug build has a unique identity and icon from your release build. Otherwise, neither the OS nor you will be able to differentiate between the two. You can achieve this by performing the following steps:
-
-1. In your `build.gradle` file, specify the [`applicationIdSuffix`](http://google.github.io/android-gradle-dsl/current/com.android.build.gradle.internal.dsl.BuildType.html#com.android.build.gradle.internal.dsl.BuildType:applicationIdSuffix) field for your debug build type, which gives your debug build a unique identity for the OS (like `com.foo` vs. `com.foo.debug`).
-
-```groovy
-buildTypes {
-    debug {
-        applicationIdSuffix ".debug"
-    }
-}
-```
-
-2. Create the `app/src/debug/res` directory structure in your app, which allows overriding resources (like strings, icons, layouts) for your debug builds
-
-3. Create a `values` directory underneath the debug res directory created in #2, and copy the existing `strings.xml` file from the `app/src/main/res/values` directory
-
-4. Open up the new debug `strings.xml` file and change the `<string name="app_name">` element's value to something else (like `foo-debug`). This ensures that your debug build now has a distinct display name, so that you can differentiate it from your release build.
-
-5. Optionally, create "mirrored" directories in the `app/src/debug/res` directory for all of your app's icons that you want to change for your debug build. This part isn't technically critical, but it can make it easier to quickly spot your debug builds on a device if its icon is noticeable different.
 
 And that's it! View [here](http://tools.android.com/tech-docs/new-build-system/resource-merging) for more details on how resource merging works in Android.