@srcpush/react-native-code-push 1.0.3-feat-new-architecture.1 → 1.0.3-feat-new-arch.1

package/android/app/src/newarch/java/com/microsoft/codepush/react/CodePushDialog.java

@@ -0,0 +1,49 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.annotations.ReactModule;
+
+@ReactModule(name = CodePushDialog.NAME)
+public class CodePushDialog extends NativeCodePushDialogSpec {
+    public static final String NAME = "CodePushDialog";
+
+    private final CodePushDialogImpl impl;
+
+    public CodePushDialog(ReactApplicationContext reactContext) {
+        super(reactContext);
+        impl = new CodePushDialogImpl(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public void showDialog(
+            String title,
+            String message,
+            String button1Text,
+            String button2Text,
+            Callback successCallback,
+            Callback errorCallback
+    ) {
+        try {
+            impl.showDialog(title, message, button1Text, button2Text, successCallback, errorCallback);
+        } catch (Throwable e) {
+            if (errorCallback != null) errorCallback.invoke(e.getMessage());
+        }
+    }
+
+    @Override
+    public void addListener(String eventName) {
+        // no-op
+    }
+
+    @Override
+    public void removeListeners(double count) {
+        // no-op
+    }
+}
+

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

@@ -0,0 +1,143 @@
+package com.microsoft.codepush.react;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.OptIn;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
+import com.facebook.react.module.annotations.ReactModule;
+
+import java.util.Map;
+
+@OptIn(markerClass = UnstableReactNativeAPI.class)
+@ReactModule(name = CodePushNativeModule.NAME)
+public class CodePushNativeModule extends NativeCodePushSpec {
+    public static final String NAME = "CodePush";
+
+    private final CodePushNativeModuleImpl impl;
+
+    public CodePushNativeModule(
+            ReactApplicationContext reactContext,
+            CodePush codePush,
+            CodePushUpdateManager codePushUpdateManager,
+            CodePushTelemetryManager codePushTelemetryManager,
+            SettingsManager settingsManager
+    ) {
+        super(reactContext);
+        impl = new CodePushNativeModuleImpl(reactContext, codePush, codePushUpdateManager, codePushTelemetryManager, settingsManager);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    protected Map<String, Object> getTypedExportedConstants() {
+        return impl.getConstants();
+    }
+
+    @Override
+    public void allow(Promise promise) {
+        impl.allow(promise);
+    }
+
+    @Override
+    public void clearPendingRestart(Promise promise) {
+        impl.clearPendingRestart(promise);
+    }
+
+    @Override
+    public void disallow(Promise promise) {
+        impl.disallow(promise);
+    }
+
+    @Override
+    public void restartApp(boolean onlyIfUpdateIsPending, Promise promise) {
+        impl.restartApp(onlyIfUpdateIsPending, promise);
+    }
+
+    @Override
+    public void downloadUpdate(ReadableMap updatePackage, boolean notifyProgress, Promise promise) {
+        impl.downloadUpdate(updatePackage, notifyProgress, promise);
+    }
+
+    @Override
+    public void getConfiguration(Promise promise) {
+        impl.getConfiguration(promise);
+    }
+
+    @Override
+    public void getUpdateMetadata(double updateState, Promise promise) {
+        impl.getUpdateMetadata(updateState, promise);
+    }
+
+    @Override
+    public void getNewStatusReport(Promise promise) {
+        impl.getNewStatusReport(promise);
+    }
+
+    @Override
+    public void installUpdate(ReadableMap updatePackage, double installMode, double minimumBackgroundDuration, Promise promise) {
+        impl.installUpdate(updatePackage, installMode, minimumBackgroundDuration, promise);
+    }
+
+    @Override
+    public void isFailedUpdate(String packageHash, Promise promise) {
+        impl.isFailedUpdate(packageHash, promise);
+    }
+
+    @Override
+    public void getLatestRollbackInfo(Promise promise) {
+        impl.getLatestRollbackInfo(promise);
+    }
+
+    @Override
+    public void setLatestRollbackInfo(String packageHash, Promise promise) {
+        impl.setLatestRollbackInfo(packageHash, promise);
+    }
+
+    @Override
+    public void isFirstRun(String packageHash, Promise promise) {
+        impl.isFirstRun(packageHash, promise);
+    }
+
+    @Override
+    public void notifyApplicationReady(Promise promise) {
+        impl.notifyApplicationReady(promise);
+    }
+
+    @Override
+    public void recordStatusReported(ReadableMap statusReport) {
+        impl.recordStatusReported(statusReport);
+    }
+
+    @Override
+    public void saveStatusReportForRetry(ReadableMap statusReport) {
+        impl.saveStatusReportForRetry(statusReport);
+    }
+
+    @Override
+    public void downloadAndReplaceCurrentBundle(String remoteBundleUrl) {
+        impl.downloadAndReplaceCurrentBundle(remoteBundleUrl);
+    }
+
+    @Override
+    public void clearUpdates() {
+        impl.clearUpdates();
+    }
+
+    @Override
+    public void addListener(String eventName) {
+        impl.addListener(eventName);
+    }
+
+    @Override
+    public void removeListeners(double count) {
+        impl.removeListeners(count);
+    }
+}
+

package/android/app/src/oldarch/java/com/microsoft/codepush/react/CodePushDialog.java

@@ -0,0 +1,49 @@
+package com.microsoft.codepush.react;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+
+public class CodePushDialog extends BaseJavaModule {
+    public static final String NAME = "CodePushDialog";
+
+    private final CodePushDialogImpl impl;
+
+    public CodePushDialog(ReactApplicationContext reactContext) {
+        super(reactContext);
+        impl = new CodePushDialogImpl(reactContext);
+    }
+
+    @ReactMethod
+    public void showDialog(
+            final String title,
+            final String message,
+            final String button1Text,
+            final String button2Text,
+            final Callback successCallback,
+            Callback errorCallback
+    ) {
+        try {
+            impl.showDialog(title, message, button1Text, button2Text, successCallback, errorCallback);
+        } catch (Throwable e) {
+            if (errorCallback != null) errorCallback.invoke(e.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // no-op
+    }
+
+    @ReactMethod
+    public void removeListeners(double count) {
+        // no-op
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+}
+

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

@@ -0,0 +1,141 @@
+package com.microsoft.codepush.react;
+
+import androidx.annotation.OptIn;
+
+import com.facebook.react.bridge.BaseJavaModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
+
+import java.util.Map;
+
+@OptIn(markerClass = UnstableReactNativeAPI.class)
+public class CodePushNativeModule extends BaseJavaModule {
+    public static final String NAME = "CodePush";
+
+    private final CodePushNativeModuleImpl impl;
+
+    public CodePushNativeModule(
+            ReactApplicationContext reactContext,
+            CodePush codePush,
+            CodePushUpdateManager codePushUpdateManager,
+            CodePushTelemetryManager codePushTelemetryManager,
+            SettingsManager settingsManager
+    ) {
+        super(reactContext);
+        impl = new CodePushNativeModuleImpl(reactContext, codePush, codePushUpdateManager, codePushTelemetryManager, settingsManager);
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        return impl.getConstants();
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void allow(Promise promise) {
+        impl.allow(promise);
+    }
+
+    @ReactMethod
+    public void clearPendingRestart(Promise promise) {
+        impl.clearPendingRestart(promise);
+    }
+
+    @ReactMethod
+    public void disallow(Promise promise) {
+        impl.disallow(promise);
+    }
+
+    @ReactMethod
+    public void restartApp(boolean onlyIfUpdateIsPending, Promise promise) {
+        impl.restartApp(onlyIfUpdateIsPending, promise);
+    }
+
+    @ReactMethod
+    public void downloadUpdate(ReadableMap updatePackage, boolean notifyProgress, Promise promise) {
+        impl.downloadUpdate(updatePackage, notifyProgress, promise);
+    }
+
+    @ReactMethod
+    public void getConfiguration(Promise promise) {
+        impl.getConfiguration(promise);
+    }
+
+    @ReactMethod
+    public void getUpdateMetadata(double updateState, Promise promise) {
+        impl.getUpdateMetadata(updateState, promise);
+    }
+
+    @ReactMethod
+    public void getNewStatusReport(Promise promise) {
+        impl.getNewStatusReport(promise);
+    }
+
+    @ReactMethod
+    public void installUpdate(ReadableMap updatePackage, double installMode, double minimumBackgroundDuration, Promise promise) {
+        impl.installUpdate(updatePackage, installMode, minimumBackgroundDuration, promise);
+    }
+
+    @ReactMethod
+    public void isFailedUpdate(String packageHash, Promise promise) {
+        impl.isFailedUpdate(packageHash, promise);
+    }
+
+    @ReactMethod
+    public void getLatestRollbackInfo(Promise promise) {
+        impl.getLatestRollbackInfo(promise);
+    }
+
+    @ReactMethod
+    public void setLatestRollbackInfo(String packageHash, Promise promise) {
+        impl.setLatestRollbackInfo(packageHash, promise);
+    }
+
+    @ReactMethod
+    public void isFirstRun(String packageHash, Promise promise) {
+        impl.isFirstRun(packageHash, promise);
+    }
+
+    @ReactMethod
+    public void notifyApplicationReady(Promise promise) {
+        impl.notifyApplicationReady(promise);
+    }
+
+    @ReactMethod
+    public void recordStatusReported(ReadableMap statusReport) {
+        impl.recordStatusReported(statusReport);
+    }
+
+    @ReactMethod
+    public void saveStatusReportForRetry(ReadableMap statusReport) {
+        impl.saveStatusReportForRetry(statusReport);
+    }
+
+    @ReactMethod
+    public void downloadAndReplaceCurrentBundle(String remoteBundleUrl) {
+        impl.downloadAndReplaceCurrentBundle(remoteBundleUrl);
+    }
+
+    @ReactMethod
+    public void clearUpdates() {
+        impl.clearUpdates();
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        impl.addListener(eventName);
+    }
+
+    @ReactMethod
+    public void removeListeners(double count) {
+        impl.removeListeners(count);
+    }
+}
+

package/docs/api-android.md

@@ -1,16 +1,16 @@
 ### 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.
+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 Source Push 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:
+  To set the public key, you should add the content of the public key to `strings.xml` with name `CodePushPublicKey`. Source Push automatically gets this property and enables the Code Signing feature. For example:
 
   ```xml
   <string moduleConfig="true" name="CodePushPublicKey">your-public-key</string>
   ```
 
-- **Server Url** - used for specifying CodePush Server Url.
-  The Default value: "<https://api.srcpush.com>" 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:
+- **Server Url** - used for specifying Source Push Server Url.
+  The Default value: "<https://api.srcpush.com>" is overridden by adding your path to `strings.xml` with name `CodePushServerUrl`. Source Push automatically gets this property and will use this path to send requests. For example:
 
   ```xml
   <string moduleConfig="true" name="CodePushServerUrl">https://api.srcpush.com</string>
@@ -22,21 +22,21 @@ The Java API is made available by importing the `com.microsoft.codepush.react.Co
 
 #### CodePush
 
-Constructs the CodePush client runtime and represents the `ReactPackage` instance that you add to you app's list of packages.
+Constructs the Source Push 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)** - Creates a new instance of the Source Push 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 Source Push 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:
+- **CodePush(String deploymentKey, Activity mainActivity, bool isDebugMode)** - Equivalent to the previous constructor but allows you to specify whether you want the Source Push 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 Source Push 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`.
+    1. Old Source Push 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.
+    2. The local cache that the React Native runtime maintains in debug mode is deleted whenever a Source Push 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://api.srcpush.com"` is overridden by value specified in `serverUrl`.
+- **CodePush(String deploymentKey, Context context, boolean isDebugMode, String serverUrl)** Constructor allows you to specify Source Push Server Url. The Default value: `"https://api.srcpush.com"` is overridden by value specified in `serverUrl`.
 
 ##### Public Methods
 

package/docs/api-ios.md

@@ -8,15 +8,15 @@ Contains static methods for retreiving the `NSURL` that represents the most rece
 
 The `CodePush` class' methods can be thought of as composite resolvers which always load the appropriate bundle, in order to accommodate the following scenarios:
 
-1. When an end-user installs your app from the store (like `1.0.0`), they will get the JS bundle that is contained within the binary. This is the behavior you would get without using CodePush, but we make sure it doesn't break :)
+1. When an end-user installs your app from the store (like `1.0.0`), they will get the JS bundle that is contained within the binary. This is the behavior you would get without using Source Push, but we make sure it doesn't break :)
 
-2. As soon as you begin releasing CodePush updates, your end-users will get the JS bundle that represents the latest release for the configured deployment. This is the behavior that allows you to iterate beyond what you shipped to the store.
+2. As soon as you begin releasing Source Push updates, your end-users will get the JS bundle that represents the latest release for the configured deployment. This is the behavior that allows you to iterate beyond what you shipped to the store.
 
-3. As soon as you release an update to the app store (like `1.1.0`), and your end-users update it, they will once again get the JS bundle that is contained within the binary. This behavior ensures that CodePush updates that targetted a previous binary version aren't used (since we don't know if they would work), and your end-users always have a working version of your app.
+3. As soon as you release an update to the app store (like `1.1.0`), and your end-users update it, they will once again get the JS bundle that is contained within the binary. This behavior ensures that Source Push updates that targetted a previous binary version aren't used (since we don't know if they would work), and your end-users always have a working version of your app.
 
-4. Repeat #2 and #3 as the CodePush releases and app store releases continue on into infinity (and beyond?)
+4. Repeat #2 and #3 as the Source Push releases and app store releases continue on into infinity (and beyond?)
 
-Because of this behavior, you can safely deploy updates to both the app store(s) and CodePush as necesary, and rest assured that your end-users will always get the most recent version.
+Because of this behavior, you can safely deploy updates to both the app store(s) and Source Push as necesary, and rest assured that your end-users will always get the most recent version.
 
 ##### Methods
 

package/docs/api-js.md

@@ -1,6 +1,6 @@
 ## API Reference
 
-The CodePush plugin is made up of two components:
+The Source Push plugin is made up of two components:
 
 1. A JavaScript module, which can be imported/required, and allows the app to interact with the service during runtime (for example check for updates, inspect the metadata about the currently running app update).
 
@@ -14,23 +14,23 @@ When you require `react-native-code-push`, the module object provides the follow
 
 * [allowRestart](#codepushallowrestart): Re-allows programmatic restarts to occur as a result of an update being installed, and optionally, immediately restarts the app if a pending update had attempted to restart the app while restarts were disallowed. This is an advanced API and is only necessary if your app explicitly disallowed restarts via the `disallowRestart` method.
 
-* [checkForUpdate](#codepushcheckforupdate): Asks the CodePush service whether the configured app deployment has an update available.
+* [checkForUpdate](#codepushcheckforupdate): Asks the Source Push service whether the configured app deployment has an update available.
 
-* [disallowRestart](#codepushdisallowrestart): Temporarily disallows any programmatic restarts to occur as a result of a CodePush update being installed. This is an advanced API, and is useful when a component within your app (for example an onboarding process) needs to ensure that no end-user interruptions can occur during its lifetime.
+* [disallowRestart](#codepushdisallowrestart): Temporarily disallows any programmatic restarts to occur as a result of a Source Push update being installed. This is an advanced API, and is useful when a component within your app (for example an onboarding process) needs to ensure that no end-user interruptions can occur during its lifetime.
 
-* [getCurrentPackage](#codepushgetcurrentpackage): Retrieves the metadata about the currently installed update (like description, installation time, size). *NOTE: As of `v1.10.3-beta` of the CodePush module, this method is deprecated in favor of [`getUpdateMetadata`](#codepushgetupdatemetadata)*.
+* [getCurrentPackage](#codepushgetcurrentpackage): Retrieves the metadata about the currently installed update (like description, installation time, size). *NOTE: As of `v1.10.3-beta` of the Source Push module, this method is deprecated in favor of [`getUpdateMetadata`](#codepushgetupdatemetadata)*.
 
 * [getUpdateMetadata](#codepushgetupdatemetadata): Retrieves the metadata for an installed update (like description, mandatory).
 
-* [notifyAppReady](#codepushnotifyappready): Notifies the CodePush runtime that an installed update is considered successful. If you are manually checking for and installing updates (i.e. not using the [sync](#codepushsync) method to handle it all for you), then this method **MUST** be called; otherwise CodePush will treat the update as failed and rollback to the previous version when the app next restarts.
+* [notifyAppReady](#codepushnotifyappready): Notifies the Source Push runtime that an installed update is considered successful. If you are manually checking for and installing updates (i.e. not using the [sync](#codepushsync) method to handle it all for you), then this method **MUST** be called; otherwise Source Push will treat the update as failed and rollback to the previous version when the app next restarts.
 
 * [restartApp](#codepushrestartapp): Immediately restarts the app. If there is an update pending, it will be immediately displayed to the end user. Otherwise, calling this method simply has the same behavior as the end user killing and restarting the process.
 
-* [sync](#codepushsync): Allows checking for an update, downloading it and installing it, all with a single call. Unless you need custom UI and/or behavior, we recommend most developers to use this method when integrating CodePush into their apps
+* [sync](#codepushsync): Allows checking for an update, downloading it and installing it, all with a single call. Unless you need custom UI and/or behavior, we recommend most developers to use this method when integrating Source Push into their apps
 
-* [clearUpdates](#clearupdates): Clear all downloaded CodePush updates. This is useful when switching to a different deployment which may have an older release than the current package. 
+* [clearUpdates](#clearupdates): Clear all downloaded Source Push updates. This is useful when switching to a different deployment which may have an older release than the current package. 
    
-    _Note: we don’t recommend to use this method in scenarios other than that (CodePush will call this method automatically when needed in other cases) as it could lead to unpredictable behavior._
+    _Note: we don’t recommend to use this method in scenarios other than that (Source Push will call this method automatically when needed in other cases) as it could lead to unpredictable behavior._
 
 #### codePush
 
@@ -162,7 +162,7 @@ Called when the sync process moves from one stage to another in the overall upda
 
 ##### codePushDownloadDidProgress (event hook)
 
-Called periodically when an available update is being downloaded from the CodePush server. The method is called with a `DownloadProgress` object, which contains the following two properties:
+Called periodically when an available update is being downloaded from the Source Push server. The method is called with a `DownloadProgress` object, which contains the following two properties:
 
 * __totalBytes__ *(Number)* - The total number of bytes expected to be received for this update (i.e. the size of the set of files which changed from the previous release).
 
@@ -176,15 +176,15 @@ codePush.allowRestart(): void;
 
 Re-allows programmatic restarts to occur, that would have otherwise been rejected due to a previous call to `disallowRestart`. If `disallowRestart` was never called in the first place, then calling this method will simply result in a no-op.
 
-If a CodePush update is currently pending, which attempted to restart the app (for example it used `InstallMode.IMMEDIATE`), but was blocked due to `disallowRestart` having been called, then calling `allowRestart` will result in an immediate restart. This allows the update to be applied as soon as possible, without interrupting the end user during critical workflows (for example an onboarding process).
+If a Source Push update is currently pending, which attempted to restart the app (for example it used `InstallMode.IMMEDIATE`), but was blocked due to `disallowRestart` having been called, then calling `allowRestart` will result in an immediate restart. This allows the update to be applied as soon as possible, without interrupting the end user during critical workflows (for example an onboarding process).
 
 For example, calling `allowRestart` would trigger an immediate restart if either of the three scenarios mentioned in the [`disallowRestart` docs](#codepushdisallowrestart) occured after `disallowRestart` was called. However, calling `allowRestart` wouldn't trigger a restart if the following were true:
 
-1. No CodePush updates were installed since the last time `disallowRestart` was called, and therefore, there isn't any need to restart anyways.
+1. No Source Push updates were installed since the last time `disallowRestart` was called, and therefore, there isn't any need to restart anyways.
 
-2. There is currently a pending CodePush update, but it was installed via `InstallMode.ON_NEXT_RESTART`, and therefore, doesn't require a programmatic restart.
+2. There is currently a pending Source Push update, but it was installed via `InstallMode.ON_NEXT_RESTART`, and therefore, doesn't require a programmatic restart.
 
-3. There is currently a pending CodePush update, but it was installed via `InstallMode.ON_NEXT_RESUME` and the app hasn't been put into the background yet, and therefore, there isn't a need to programmatically restart yet.
+3. There is currently a pending Source Push update, but it was installed via `InstallMode.ON_NEXT_RESUME` and the app hasn't been put into the background yet, and therefore, there isn't a need to programmatically restart yet.
 
 4. No calls to `restartApp` were made since the last time `disallowRestart` was called.
 
@@ -198,7 +198,7 @@ See [disallowRestart](#codepushdisallowrestart) for an example of how this metho
 codePush.checkForUpdate(deploymentKey: String = null, handleBinaryVersionMismatchCallback: (update: RemotePackage) => void): Promise<RemotePackage>;
 ```
 
-Queries the CodePush service to see whether the configured app deployment has an update available. By default, it will use the deployment key that is configured in your `Info.plist` file (iOS), or `MainActivity.java` file (Android), but you can override that by specifying a value via the optional `deploymentKey` parameter. This can be useful when you want to dynamically "redirect" a user to a specific deployment, such as allowing "early access" via an easter egg or a user setting switch.
+Queries the Source Push service to see whether the configured app deployment has an update available. By default, it will use the deployment key that is configured in your `Info.plist` file (iOS), or `MainActivity.java` file (Android), but you can override that by specifying a value via the optional `deploymentKey` parameter. This can be useful when you want to dynamically "redirect" a user to a specific deployment, such as allowing "early access" via an easter egg or a user setting switch.
 
 Second optional parameter `handleBinaryVersionMismatchCallback` is an optional callback function that can be used to notify user if there are any binary update.
 E.g. consider a use-case where currently installed binary version is 1.0.1 with label(codepush label) v1. Later native code was changed in the dev cycle and binary version was updated to 1.0.2. When code-push update check is triggered we ignore updates having binary version mismatch (because the update is not targeting to the binary version of currently installed app). In this case installed app (1.0.1) will ignore the update targeting version 1.0.2. You can use `handleBinaryVersionMismatchCallback` to provide a hook to handle such situations.
@@ -240,15 +240,15 @@ codePush.disallowRestart(): void;
 
 Temporarily disallows programmatic restarts to occur as a result of either of following scenarios:
 
-1. A CodePush update is installed using `InstallMode.IMMEDIATE`
-2. A CodePush update is installed using `InstallMode.ON_NEXT_RESUME` and the app is resumed from the background (optionally being throttled by the `minimumBackgroundDuration` property)
+1. A Source Push update is installed using `InstallMode.IMMEDIATE`
+2. A Source Push update is installed using `InstallMode.ON_NEXT_RESUME` and the app is resumed from the background (optionally being throttled by the `minimumBackgroundDuration` property)
 3. The `restartApp` method was called
 
 *NOTE: #1 and #2 effectively work by calling `restartApp` for you, so you can think of `disallowRestart` as blocking any call to `restartApp`, regardless if your app calls it directly or indirectly.*
 
 After calling this method, any calls to `sync` would still be allowed to check for an update, download it and install it, but an attempt to restart the app would be queued until `allowRestart` is called. This way, the restart request is captured and can be "flushed" whenever you want to allow it to occur.
 
-This is an advanced API, and is primarily useful when individual components within your app (like an onboarding process) need to ensure that no end-user interruptions can occur during their lifetime, while continuing to allow the app to keep syncing with the CodePush server at its own pace and using whatever install modes are appropriate. This has the benefit of allowing the app to discover and download available updates as soon as possible, while also preventing any disruptions during key end-user experiences.
+This is an advanced API, and is primarily useful when individual components within your app (like an onboarding process) need to ensure that no end-user interruptions can occur during their lifetime, while continuing to allow the app to keep syncing with the Source Push server at its own pace and using whatever install modes are appropriate. This has the benefit of allowing the app to discover and download available updates as soon as possible, while also preventing any disruptions during key end-user experiences.
 
 As an alternative, you could also choose to simply use `InstallMode.ON_NEXT_RESTART` whenever calling `sync` (which will never attempt to programmatically restart the app), and then explicity calling `restartApp` at points in your app that you know it is "safe" to do so. `disallowRestart` provides an alternative approach to this when the code that synchronizes with the CodePush server is separate from the code/components that want to enforce a no-restart policy.
 

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

@@ -4,7 +4,7 @@
 >
 > Complete demo configured with "multi-deployment testing" feature is [here](https://github.com/microsoft/react-native-code-push/files/1314118/rncp1004.zip).
 
-The [Android Gradle plugin](https://google.github.io/android-gradle-dsl/current/index.html) allows you to define custom config settings for each "build type" (like debug, release). This mechanism allows you to easily configure your debug builds to use your CodePush staging deployment key and your release builds to use your CodePush production deployment key.
+The [Android Gradle plugin](https://google.github.io/android-gradle-dsl/current/index.html) allows you to define custom config settings for each "build type" (like debug, release). This mechanism allows you to easily configure your debug builds to use your Source Push staging deployment key and your release builds to use your Source Push production deployment key.
 
 *NOTE: As a reminder, you can retrieve these keys by running `srcpush deployment ls <appName> -k` from your terminal.*
 
@@ -22,7 +22,7 @@ To set this up, perform the following steps:
         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.
+                // Note: Source Push updates should not be tested in Debug mode as they are overriden by the RN packager. However, because Source Push checks for updates in all modes, we must supply a key.
                 resValue "string", "CodePushDeploymentKey", '""'
                 ...
             }

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

@@ -7,7 +7,7 @@
 > * **without using cocoa pods**: [link](https://github.com/microsoft/react-native-code-push/files/1259957/rncp976.copy.zip)
 > * **using cocoa pods**: [link](https://github.com/microsoft/react-native-code-push/files/1172217/rncp893.copy.zip)
 
-Xcode allows you to define custom build settings for each "configuration" (like debug, release), which can then be referenced as the value of keys within the `Info.plist` file (like the `CodePushDeploymentKey` setting). This mechanism allows you to easily configure your builds to produce binaries, which are configured to synchronize with different CodePush deployments.
+Xcode allows you to define custom build settings for each "configuration" (like debug, release), which can then be referenced as the value of keys within the `Info.plist` file (like the `CodePushDeploymentKey` setting). This mechanism allows you to easily configure your builds to produce binaries, which are configured to synchronize with different Source Push deployments.
 
 To set this up, perform the following steps:
 

package/docs/setup-android.md

@@ -3,7 +3,7 @@
 * [Plugin Installation and Configuration for React Native 0.76 version and above](#plugin-installation-and-configuration-for-react-native-060-version-and-above-android)
 * [Code Signing setup](#code-signing-setup)
 
-In order to integrate CodePush into your Android project, please perform the following steps:
+In order to integrate Source Push into your Android project, please perform the following steps:
 
 ### Plugin Installation and Configuration for React Native 0.76 version and above (Android)
 
@@ -15,7 +15,7 @@ In order to integrate CodePush into your Android project, please perform the fol
     ...
     ```
 
-2. Update the `MainApplication` file to use CodePush via the following changes:
+2. Update the `MainApplication` file to use Source Push via the following changes:
 
    For React Native 0.76 and above: update the `MainApplication.kt`
 
@@ -35,7 +35,7 @@ In order to integrate CodePush into your Android project, please perform the fol
                 }
 
                // 2. Override the getJSBundleFile method in order to let
-               // the CodePush runtime determine where to get the JS
+               // the Source Push runtime determine where to get the JS
                // bundle location from on each app start
                override fun getJSBundleFile(): String {
                  return CodePush.getJSBundleFile() 
@@ -46,7 +46,7 @@ In order to integrate CodePush into your Android project, please perform the fol
 
 3. Add the Deployment key to `strings.xml`:
 
-   To let the CodePush runtime know which deployment it should query for updates, open your app's `strings.xml` file and
+   To let the Source Push runtime know which deployment it should query for updates, open your app's `strings.xml` file and
 add a new string named `CodePushDeploymentKey`, whose value is the key of the deployment you want to configure this app against
 (like the key for the `Staging` deployment for the `FooBar` app). You can retrieve this value by running `srcpush deployment ls <appName> -k`
 in the Source Push CLI (the `-k` or `--displayKeys` flag is necessary since keys aren't displayed by default) or take in [Source Push UI](https://console.srcpush.com/applications)
@@ -55,7 +55,7 @@ The "friendly name" is intended only for authenticated management usage from the
 
    ![Deployment list](https://cloud.githubusercontent.com/assets/116461/11601733/13011d5e-9a8a-11e5-9ce2-b100498ffb34.png)
 
-   In order to effectively make use of the `Staging` and `Production` deployments that were created along with your CodePush app, refer to the [multi-deployment testing](../README.md#multi-deployment-testing) docs below before actually moving your app's usage of CodePush into production.
+   In order to effectively make use of the `Staging` and `Production` deployments that were created along with your Source Push app, refer to the [multi-deployment testing](../README.md#multi-deployment-testing) docs below before actually moving your app's usage of Source Push into production.
 
    Your `strings.xml` should look like this:
 
@@ -68,11 +68,11 @@ The "friendly name" is intended only for authenticated management usage from the
 
    *Note: If you need to dynamically use a different deployment, you can also override your deployment key in JS code using [Code-Push options](./api-js.md#CodePushOptions)*
 
-In order to effectively make use of the `Staging` and `Production` deployments that were created along with your CodePush app, refer to the [multi-deployment testing](../README.md#multi-deployment-testing) docs below before actually moving your app's usage of CodePush into production.
+In order to effectively make use of the `Staging` and `Production` deployments that were created along with your Source Push app, refer to the [multi-deployment testing](../README.md#multi-deployment-testing) docs below before actually moving your app's usage of Source Push into production.
 
 ### Code Signing setup
 
-You can self sign bundles during release and verify its signature before installation of update. For more info about Code Signing please refer to [relevant code-push documentation section](https://github.com/microsoft/code-push/tree/v3.0.1/cli#code-signing).
+You can self sign bundles during release and verify its signature before installation of update. For more info about Code Signing please refer to [relevant Source Push documentation section](https://docs.srcpush.com).
 In order to use Public Key for Code Signing you need to do following steps:
 
 Add `CodePushPublicKey` string item to `/path_to_your_app/android/app/src/main/res/values/strings.xml`. It may look like this: