@bravemobile/react-native-code-push 13.1.0-beta.3 → 13.1.0-beta.5

package/CodePush.podspec

@@ -36,6 +36,11 @@ Pod::Spec.new do |s|
   ]
   s.public_header_files = ['ios/CodePush/CodePush.h']
 
+  s.test_spec 'Tests' do |test_spec|
+    test_spec.source_files = 'ios/CodePushTests/**/*.{h,m}'
+    test_spec.resources = 'cli/fixtures/binary-patch/*'
+  end
+
   binary_patch_header_search_paths = '"$(PODS_TARGET_SRCROOT)/cpp/binarypatch" "$(PODS_TARGET_SRCROOT)/cpp/binarypatch/vendor/HDiffPatch" "$(PODS_TARGET_SRCROOT)/cpp/binarypatch/vendor/zstd"'
   # ZSTD_DISABLE_ASM: the assembly fast path is intentionally not vendored.
   # _IS_USED_MULTITHREAD=0: patches are applied on the thread that downloads them.

package/README.md

@@ -5,6 +5,7 @@
 - **No API Server Needed** – Use static hosting solutions (e.g., AWS S3) without maintaining additional API servers.
 - **Familiar API** – Built on `microsoft/react-native-code-push`, with the native module migrated to TurboModule.
 - **Flexible Deployment** – Implement your own release workflow, giving you complete control over the deployment process.
+- **Diff Updates** – Publish [binary patch and asset diff releases](docs/diff-updates.md) so a client downloads the difference from what it already holds, not the whole bundle.
 
 ### 🚀 New Architecture support
 
@@ -292,76 +293,12 @@ export default CodePush({
 
 #### 4-1. Telemetry Callbacks
 
-Please refer to the [CodePushOptions](https://github.com/Soomgo-Mobile/react-native-code-push/blob/f0d26f7614af41c6dd4daecd9f7146e2383b2b0d/typings/react-native-code-push.d.ts#L76-L95) type for more details.
-- **onUpdateSuccess:** Triggered when the update bundle is executed successfully.
-- **onUpdateRollback:** Triggered when there is an issue executing the update bundle, leading to a rollback.
-- **onDownloadStart:** Triggered when the bundle download begins.
-- **onDownloadSuccess:** Triggered when the bundle download completes successfully.
-- **onSyncError:** Triggered when an unknown error occurs during the update process. (`CodePush.SyncStatus.UNKNOWN_ERROR` status)
-- **onBinaryPatchResult:** Triggered when an update that was published with a binary patch has been downloaded, with the release label and how the patch went. Unlike the callbacks above, this one can also be passed to a single `sync()` call - see below.
+`CodePushOptions` takes optional callbacks that report what an update did - when it was
+downloaded, whether it ran or was rolled back, and which archive it came from. They are
+purely for observation.
 
-`onBinaryPatchResult` is called with `{ status: "applied" | "fallback", fallbackReason?: string, applyDurationMs: number }`.
-A `"fallback"` is not a failed update: the update is downloaded in full instead and installed as usual, so the result
-is there to be observed and nothing more. The library neither stores it nor sends it anywhere - an app that wants it in
-its telemetry sends it itself. A callback that throws never fails the update - the error is only logged to the console.
-A fallback also shows in `downloadProgressCallback`: the full download reports a second progress stream that counts
-`receivedBytes` from zero again, against its own, larger `totalBytes`.
-
-Register `onBinaryPatchResult` on `CodePush({ ... })` like the callbacks above and it covers every sync, whatever the `checkFrequency` is
-and including the `CodePush.sync()` calls you make yourself.
-
-```typescript
-export default CodePush({
-  checkFrequency: CodePush.CheckFrequency.MANUAL, // or something else
-  releaseHistoryFetcher: releaseHistoryFetcher,
-  onBinaryPatchResult: (label, result) => {
-    // Send it to your own telemetry, if you want it there.
-  },
-})(MyApp);
-```
-
-Pass it to a `sync()` call to override the registered one for that call - to tag the result of one particular sync,
-for instance.
-
-```typescript
-CodePush.sync({
-  onBinaryPatchResult: (label, result) => {
-    // Send it to your own telemetry, if you want it there.
-  },
-});
-```
-
-
-#### 4-2. Asset Diff Archives
-
-A release published with a binary patch can carry **asset diff archives** as well - one per
-recently released version. A diff archive holds the patch of the JS bundle, only the assets
-that version does not already have, and a manifest of the files it has to drop. The client
-copies the update it already has installed, applies those, and ends up holding exactly the
-contents of the full archive.
-
-So one release has a full archive, a patch archive and up to `--diff-base-count` diff
-archives, and a client downloads one of them per attempt: the diff archive built against
-the update it is running, when the release has one, and the patch archive when it is
-running the bundle in the binary or an update this release was not diffed against.
-
-Diff archives are published only when all three of these hold:
-- the release is a binary patch release (`release --binary-bundle-path`),
-- `code-push.config.ts` implements `bundleDownloader`, so the CLI can fetch the earlier releases to diff against,
-- `--diff-base-count` is greater than `0` (it defaults to `3`).
-
-```ts
-bundleDownloader: async (downloadUrl) => {
-    const downloadedFilePath = path.join(os.tmpdir(), path.basename(new URL(downloadUrl).pathname));
-    // fetch the archive from your storage (S3, GCS, ...) to downloadedFilePath
-    return { downloadedFilePath };
-},
-```
-
-Rebuilding the update from a diff archive falls back the way a patch does: the update is
-downloaded in full instead, and `onBinaryPatchResult` reports it as
-`{ status: "fallback", fallbackReason: "package_verification_failed" }`. See
-[Asset diff archives](cli/README.md#asset-diff-archives) for what the release publishes.
+See [Telemetry callbacks](docs/telemetry-callbacks.md) for what each one receives and how to
+register them.
 
 
 ### 5. Configure the CLI Tool
@@ -372,7 +309,7 @@ downloaded in full instead, and `onBinaryPatchResult` reports it as
 **(1) Create a `code-push.config.ts` file in the root directory of your project.**
 
 Then, implement three functions to upload the bundle file and create/update the release history,
-plus an optional fourth one - `bundleDownloader` - if you publish [asset diff archives](#4-2-asset-diff-archives).
+plus an optional fourth one - `bundleDownloader` - if you publish [asset diff archives](docs/diff-updates.md#asset-diff-archives).
 The CLI tool uses these functions to release CodePush updates and manage releases.
 (These functions are not used at runtime by the library.)
 
@@ -389,6 +326,7 @@ const Config: CliConfigInterface = {
     source: string,
     platform: "ios" | "android",
     identifier,
+    artifact,
   ): Promise<{downloadUrl: string}> => {
     // ...
   },
@@ -413,7 +351,7 @@ const Config: CliConfigInterface = {
 
   // Only needed to publish asset diff archives (see "4-2. Asset Diff Archives").
   // bundleDownloader: async (
-  //   downloadUrl: string,
+  //   archive,
   //   platform: "ios" | "android",
   //   identifier,
   // ): Promise<{downloadedFilePath: string}> => {
@@ -427,6 +365,9 @@ module.exports = Config;
 
 **`bundleUploader`**
 - Implements a function to upload the bundle file.
+- The optional `artifact` argument identifies the full bundle, binary patch, or asset diff
+  archive. The `release` command always provides it, including the target binary version and
+  the package hashes needed to construct a storage key without parsing a file name.
 - The `downloadUrl` returned by this function is recorded in `ReleaseHistoryInterface` data
   and is used by the library runtime to download the bundle file from this URL.
 - Used in the following cases:
@@ -474,82 +415,16 @@ module.exports = Config;
 ```
 
 
-### 6. Export the Embedded Bundle (Optional)
-
-Only needed if you want to release **binary patch updates** (`release --binary-bundle-path`).
-A binary patch is the difference between the update and the JS bundle that is already
-inside the installed app, so releasing one means holding on to that bundle: the exact
-bytes the build you shipped to the store embedded.
-
-The library ships a hook for each platform that copies the freshly compiled bundle out of
-the build, together with a `binary-patch-base.json` record describing it.
+### 6. Diff Updates (Optional)
 
-**Android** - apply the Gradle script in your app module's `android/app/build.gradle`:
+In place of the full archive, a release can offer a binary patch computed against the JS
+bundle inside the app binary. A release that carries one can also carry an asset diff, for a
+client running one of the recent updates the release was diffed against. Both need a build
+hook that copies the JS bundle out of your store build; asset diffs also need a
+`bundleDownloader` in `code-push.config.ts`.
 
-```groovy
-apply plugin: "com.android.application"
-apply plugin: "com.facebook.react"
-
-react {
-    // ...
-}
-
-apply from: "../../node_modules/@bravemobile/react-native-code-push/android/codepush-export.gradle"
-```
-
-The line can go anywhere in the file (if you use `ext.codePushExportDir`, set it before the
-`apply from:` line). Every variant that bundles JS then exports to
-`android/app/build/codepush/embedded-bundle/<variant>/` after it is bundled. Pass
-`-PcodePushExportDir=<path>` (or set `ext.codePushExportDir`) to export somewhere else; the
-`<variant>` directory is appended either way.
-
-**iOS** - call the export script at the end of the **"Bundle React Native code and images"**
-build phase. In Xcode, open that phase
-in your app target's **Build Phases** tab and append the last line below to its script:
-
-```bash
-/bin/sh -c "\"$WITH_ENVIRONMENT\" \"$REACT_NATIVE_XCODE\""
-
-"$SRCROOT/../node_modules/@bravemobile/react-native-code-push/scripts/export-embedded-bundle.sh"
-```
-
-The export lands in `$BUILD_DIR/codepush/embedded-bundle/$CONFIGURATION-$PLATFORM_NAME/`.
-Set the `CODEPUSH_EXPORT_DIR` environment variable to export somewhere else; the
-`$CONFIGURATION-$PLATFORM_NAME` directory is appended either way.
-
-**Archive the export per binary release.** Whatever pipeline builds your store binary
-should keep that build's export somewhere durable, organized by binary version, so a later
-release can fetch the bundle that matches the binary it targets:
-
-```bash
-# Android, after ./gradlew :app:assembleRelease
-aws s3 cp --recursive \
-  android/app/build/codepush/embedded-bundle/release \
-  "s3://your-bucket/binaries/android/$BINARY_VERSION/"
-
-# iOS - point the export at a path the pipeline knows, since $BUILD_DIR only exists inside the build
-export CODEPUSH_EXPORT_DIR="$PWD/codepush-export"
-xcodebuild -workspace ios/YourApp.xcworkspace -scheme YourApp -configuration Release archive # ...
-aws s3 cp --recursive \
-  "$CODEPUSH_EXPORT_DIR/Release-iphoneos" \
-  "s3://your-bucket/binaries/ios/$BINARY_VERSION/"
-```
-
-To release a patch later, download the export and pass the bundle's path to
-`--binary-bundle-path`:
-
-```bash
-aws s3 cp --recursive "s3://your-bucket/binaries/android/1.0.0/" ./binary/
-npx code-push release -b 1.0.0 -v 1.0.1 -p android \
-                      --binary-bundle-path ./binary/index.android.bundle
-```
-
-`release` also uses the record to verify the base bundle it was handed - see
-[Verifying the base bundle](cli/README.md#verifying-the-base-bundle) for details.
-
-> [!NOTE]
-> Applying these hooks automatically through the Expo config plugin (`app.plugin.js`) is
-> not implemented yet.
+See [Diff updates](docs/diff-updates.md) for the hooks, what to keep per binary version, and
+how a client picks an archive.
 
 
 ## 🚀 CLI Tool Usage

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

@@ -0,0 +1,181 @@
+package com.microsoft.codepush.react;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The record of installing an update from its update archives: which archives were tried,
+ * whether the update was installed from one of them, why the full archive had to be
+ * downloaded when it was not, and how long the work took.
+ *
+ * The record exists for an app that wants to judge an archive rollout with its own telemetry,
+ * so it travels to whoever asked for the download and nowhere else. It is not part of the
+ * update's metadata, it is never written to disk, and nothing here sends it anywhere.
+ */
+class ArchiveAttemptLog {
+
+    static final String ARCHIVE_ASSET_DIFF = "asset-diff";
+    static final String ARCHIVE_BINARY_PATCH = "binary-patch";
+
+    private static final String APPLY_DURATION_MS_KEY = "applyDurationMs";
+    private static final String ARCHIVE_KEY = "archive";
+    private static final String ATTEMPTS_KEY = "attempts";
+    private static final String DURATION_MS_KEY = "durationMs";
+    private static final String FALLBACK_REASON_KEY = "fallbackReason";
+    private static final String STATUS_KEY = "status";
+    private static final String TOTAL_DURATION_MS_KEY = "totalDurationMs";
+
+    private static final String STATUS_APPLIED = "applied";
+    private static final String STATUS_FALLBACK = "fallback";
+
+    /** One archive being tried, timed from the moment it was started. */
+    private static class Attempt {
+        final String archive;
+        final long startTimeMs = System.currentTimeMillis();
+
+        /** How long the applier took, once it has restored the bundle. */
+        long applyDurationMs = -1;
+
+        boolean fellBack;
+        String fallbackReason;
+        long durationMs = -1;
+
+        /** Whether the server answered this archive's URL with a status instead of the archive. */
+        boolean wasNotServed;
+
+        Attempt(String archive) {
+            this.archive = archive;
+        }
+    }
+
+    private final List<Attempt> mAttempts = new ArrayList<>();
+
+    /** When the first archive was started, which is where a fallback's total time runs from. */
+    private long mFirstAttemptStartTimeMs = -1;
+    private long mTotalDurationMs = -1;
+
+    /** Starts trying one archive. Everything recorded next is about this archive. */
+    void beginAttempt(String archive) {
+        if (mFirstAttemptStartTimeMs < 0) {
+            mFirstAttemptStartTimeMs = System.currentTimeMillis();
+        }
+        mAttempts.add(new Attempt(archive));
+    }
+
+    /**
+     * The applier restored the bundle. Whether the update installs is decided by the checks
+     * that follow, so this is not yet the attempt succeeding.
+     */
+    void recordBundleRestored(long applyDurationMs) {
+        current().applyDurationMs = applyDurationMs;
+    }
+
+    /**
+     * Whether the current archive's attempt got as far as restoring the bundle. A failure
+     * after that point is on the asset side of the archive, which the archives do not share -
+     * unlike the bundle patch, which they carry byte for byte.
+     */
+    boolean currentAttemptRestoredBundle() {
+        return current().applyDurationMs >= 0;
+    }
+
+    /**
+     * Whether the current archive never arrived, because the server answered its URL with a
+     * status rather than with the archive.
+     *
+     * A verdict on one URL, and the archives are at URLs of their own: a release whose diff
+     * has been cleaned up still has its patch archive. This is the one failure before the
+     * bundle is restored that says nothing about the archives left to try.
+     */
+    boolean currentAttemptWasNotServed() {
+        return current().wasNotServed;
+    }
+
+    /**
+     * The attempt at the current archive ended in one of the reasons the appliers report.
+     *
+     * The attempt is timed here rather than when it is read, because what happens next is
+     * another archive being downloaded and that is not time this attempt spent.
+     */
+    void recordFallback(String failureReason) {
+        Attempt attempt = current();
+        attempt.fellBack = true;
+        attempt.fallbackReason = failureReason;
+        long now = System.currentTimeMillis();
+        attempt.durationMs = now - attempt.startTimeMs;
+        mTotalDurationMs = now - mFirstAttemptStartTimeMs;
+    }
+
+    /**
+     * The attempt ended in an error rather than in a verdict of its own.
+     *
+     * An error raised after the bundle was restored is the restored update failing the checks
+     * that every update passes before it is installed. Before that point the appliers have no
+     * word for what happened - the archive not being downloadable, say - and inventing one
+     * here would put a value on the wire that no platform reports, so the fallback is
+     * reported without a reason.
+     */
+    void recordFallbackAfterError(Throwable error) {
+        current().wasNotServed = CodePushErrorCode.HTTP.equals(CodePushErrorCode.of(error));
+        recordFallback(currentAttemptRestoredBundle() ? ArchiveRestoreResult.REASON_PACKAGE_VERIFICATION_FAILED : null);
+    }
+
+    /** The archive being tried, for the log lines that name which one failed. */
+    String currentArchive() {
+        return current().archive;
+    }
+
+    private Attempt current() {
+        return mAttempts.get(mAttempts.size() - 1);
+    }
+
+    /**
+     * What the attempts ended in, as the app reads it.
+     *
+     * The result times the whole patch path: from the first archive starting to download to
+     * the last attempt being finished with, whichever way it ended. The attempts array retells
+     * the archives one by one, each timed over its own try and carrying the time its applier
+     * took when it got as far as restoring the bundle.
+     */
+    JSONObject result() {
+        Attempt last = current();
+        boolean applied = !last.fellBack;
+        long now = System.currentTimeMillis();
+
+        JSONObject result = new JSONObject();
+        CodePushUtils.setJSONValueForKey(result, STATUS_KEY, applied ? STATUS_APPLIED : STATUS_FALLBACK);
+        CodePushUtils.setJSONValueForKey(result, ARCHIVE_KEY, last.archive);
+        if (last.fallbackReason != null) {
+            CodePushUtils.setJSONValueForKey(result, FALLBACK_REASON_KEY, last.fallbackReason);
+        }
+
+        // A path that was given up on was timed when it was, before the full download it
+        // must not include. One that installed is timed here, because nothing else marks
+        // the moment it finished - and mTotalDurationMs cannot stand in for it, because an
+        // earlier attempt that fell back froze it partway through the path.
+        CodePushUtils.setJSONValueForKey(result, TOTAL_DURATION_MS_KEY,
+                applied ? now - mFirstAttemptStartTimeMs : mTotalDurationMs);
+
+        JSONArray attempts = new JSONArray();
+        for (Attempt attempt : mAttempts) {
+            JSONObject entry = new JSONObject();
+            CodePushUtils.setJSONValueForKey(entry, ARCHIVE_KEY, attempt.archive);
+            if (attempt.fallbackReason != null) {
+                CodePushUtils.setJSONValueForKey(entry, FALLBACK_REASON_KEY, attempt.fallbackReason);
+            }
+            CodePushUtils.setJSONValueForKey(entry, DURATION_MS_KEY,
+                    attempt.fellBack ? attempt.durationMs : now - attempt.startTimeMs);
+            // An attempt that never restored the bundle has no apply to report.
+            if (attempt.applyDurationMs >= 0) {
+                CodePushUtils.setJSONValueForKey(entry, APPLY_DURATION_MS_KEY, attempt.applyDurationMs);
+            }
+            attempts.put(entry);
+        }
+        CodePushUtils.setJSONValueForKey(result, ATTEMPTS_KEY, attempts);
+
+        return result;
+    }
+}

package/android/app/src/main/java/com/microsoft/codepush/react/{BinaryPatchResult.java → ArchiveRestoreResult.java}

@@ -1,14 +1,14 @@
 package com.microsoft.codepush.react;
 
 /**
- * Outcome of restoring an update from its binary patch archive.
+ * Outcome of restoring an update from one of its update archives.
  *
  * A failed result is not an error the user hears about: it is the signal to download the
  * update's full archive instead. The reason strings are the vocabulary the appliers of
  * every platform report, and the logs a rollout is judged from are read for exactly these
  * words, so they must not be reworded.
  */
-public class BinaryPatchResult {
+public class ArchiveRestoreResult {
 
     /** The bundle inside the app binary could not be opened or read. */
     public static final String REASON_BASE_BUNDLE_UNAVAILABLE = "base_bundle_unavailable";
@@ -28,6 +28,16 @@ public class BinaryPatchResult {
     /** The restored bundle is not the one the manifest promised. */
     public static final String REASON_TARGET_VERIFICATION_FAILED = "target_verification_failed";
 
+    /**
+     * The asset diff could not be merged with the installed update it was built against.
+     *
+     * Reported by the caller too, from the merge that follows the restore: the diff archive
+     * only carries what the installed update does not, so this covers reading the installed
+     * update's files, applying the deletion manifest, and everything else that stitches the
+     * two back together.
+     */
+    public static final String REASON_ASSET_MERGE_FAILED = "asset_merge_failed";
+
     /**
      * The update restored from the patch did not pass the checks every update passes before
      * it is installed - the folder hash above all.
@@ -40,17 +50,17 @@ public class BinaryPatchResult {
     private final boolean mSucceeded;
     private final String mFailureReason;
 
-    private BinaryPatchResult(boolean succeeded, String failureReason) {
+    private ArchiveRestoreResult(boolean succeeded, String failureReason) {
         mSucceeded = succeeded;
         mFailureReason = failureReason;
     }
 
-    public static BinaryPatchResult success() {
-        return new BinaryPatchResult(true, null);
+    public static ArchiveRestoreResult success() {
+        return new ArchiveRestoreResult(true, null);
     }
 
-    public static BinaryPatchResult failure(String failureReason) {
-        return new BinaryPatchResult(false, failureReason);
+    public static ArchiveRestoreResult failure(String failureReason) {
+        return new ArchiveRestoreResult(false, failureReason);
     }
 
     public boolean succeeded() {

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

@@ -26,7 +26,7 @@ import java.io.OutputStream;
  * hashed before the patch is applied and the restored bundle is hashed afterwards, and
  * the restored bytes only reach the update contents once both checks have passed.
  *
- * Every failure is reported as a {@link BinaryPatchResult}, never as an exception: the
+ * Every failure is reported as a {@link ArchiveRestoreResult}, never as an exception: the
  * caller answers all of them the same way, by downloading the full archive instead.
  */
 public class CodePushBinaryPatch {
@@ -74,11 +74,11 @@ public class CodePushBinaryPatch {
      *                             and after the attempt so an interrupted run leaves nothing
      * @param baseBundleFileName   name of the JS bundle inside the app binary
      */
-    public BinaryPatchResult restoreBundle(String unzippedFolderPath, String workingFolderPath, String baseBundleFileName) {
+    public ArchiveRestoreResult restoreBundle(String unzippedFolderPath, String workingFolderPath, String baseBundleFileName) {
         File contentsFolder = resolveContentsFolder(new File(unzippedFolderPath));
         File manifestFile = new File(contentsFolder, CodePushConstants.BINARY_PATCH_MANIFEST_FILE_NAME);
         if (!manifestFile.isFile()) {
-            return BinaryPatchResult.failure(BinaryPatchResult.REASON_INVALID_MANIFEST);
+            return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_INVALID_MANIFEST);
         }
 
         JSONObject manifest;
@@ -86,12 +86,12 @@ public class CodePushBinaryPatch {
             manifest = CodePushUtils.getJsonObjectFromFile(manifestFile.getAbsolutePath());
         } catch (IOException | CodePushMalformedDataException e) {
             CodePushUtils.log(e);
-            return BinaryPatchResult.failure(BinaryPatchResult.REASON_INVALID_MANIFEST);
+            return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_INVALID_MANIFEST);
         }
 
         if (manifest.optInt(CodePushConstants.BINARY_PATCH_FORMAT_VERSION_KEY, -1) != CodePushConstants.BINARY_PATCH_FORMAT_VERSION
                 || !CodePushConstants.BINARY_PATCH_ALGORITHM.equals(manifest.optString(CodePushConstants.BINARY_PATCH_ALGORITHM_KEY, null))) {
-            return BinaryPatchResult.failure(BinaryPatchResult.REASON_UNSUPPORTED_FORMAT);
+            return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_UNSUPPORTED_FORMAT);
         }
 
         File targetBundleFile = resolveInsideFolder(contentsFolder, manifest.optString(CodePushConstants.BINARY_PATCH_BUNDLE_PATH_KEY, null));
@@ -102,7 +102,7 @@ public class CodePushBinaryPatch {
         if (targetBundleFile == null || patchFile == null || !patchFile.isFile()
                 || isNullOrEmpty(baseBundleHash) || isNullOrEmpty(targetBundleHash)
                 || targetBundleSize <= 0 || targetBundleSize > CodePushConstants.BINARY_PATCH_MAX_TARGET_BUNDLE_SIZE) {
-            return BinaryPatchResult.failure(BinaryPatchResult.REASON_INVALID_MANIFEST);
+            return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_INVALID_MANIFEST);
         }
 
         // An earlier attempt that was killed while patching leaves its restored bundle behind.
@@ -110,13 +110,13 @@ public class CodePushBinaryPatch {
         File workingFolder = new File(workingFolderPath);
         if (!workingFolder.mkdirs()) {
             CodePushUtils.log("Unable to create the binary patch working directory at " + workingFolderPath);
-            return BinaryPatchResult.failure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED);
+            return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED);
         }
 
         try {
             if (workingFolder.getUsableSpace() < targetBundleSize) {
                 CodePushUtils.log("Not enough free space to restore a " + targetBundleSize + " byte bundle.");
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED);
             }
 
             byte[] baseBundle;
@@ -124,13 +124,13 @@ public class CodePushBinaryPatch {
                 baseBundle = mBaseBundleProvider.readBaseBundle(baseBundleFileName);
             } catch (Exception e) {
                 CodePushUtils.log(e);
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_BASE_BUNDLE_UNAVAILABLE);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_BASE_BUNDLE_UNAVAILABLE);
             }
             if (baseBundle == null) {
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_BASE_BUNDLE_UNAVAILABLE);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_BASE_BUNDLE_UNAVAILABLE);
             }
             if (!baseBundleHash.equals(CodePushUpdateUtils.computeHashForBytes(baseBundle))) {
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_BASE_HASH_MISMATCH);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_BASE_HASH_MISMATCH);
             }
 
             byte[] patch;
@@ -138,38 +138,38 @@ public class CodePushBinaryPatch {
                 patch = readFile(patchFile);
             } catch (IOException e) {
                 CodePushUtils.log(e);
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED);
             }
 
             File restoredBundleFile = new File(workingFolder, CodePushConstants.BINARY_PATCH_TARGET_FILE_NAME);
             int resultCode = mPatchApplier.apply(baseBundle, patch, restoredBundleFile.getAbsolutePath(), targetBundleSize);
             if (resultCode != PatchApplier.RESULT_OK) {
                 CodePushUtils.log("The binary patch applier returned " + resultCode + ".");
-                return BinaryPatchResult.failure(reasonForResultCode(resultCode));
+                return ArchiveRestoreResult.failure(reasonForResultCode(resultCode));
             }
 
             if (restoredBundleFile.length() != targetBundleSize) {
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_TARGET_VERIFICATION_FAILED);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED);
             }
             String restoredBundleHash;
             try {
                 restoredBundleHash = CodePushUpdateUtils.computeHashForFile(restoredBundleFile);
             } catch (IOException e) {
                 CodePushUtils.log(e);
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_TARGET_VERIFICATION_FAILED);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED);
             }
             if (!targetBundleHash.equals(restoredBundleHash)) {
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_TARGET_VERIFICATION_FAILED);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_TARGET_VERIFICATION_FAILED);
             }
 
             if (!moveFile(restoredBundleFile, targetBundleFile) || !patchFile.delete() || !manifestFile.delete()) {
                 // The contents are half restored, so they must not be installed. The full
                 // archive that follows unzips over them, which is what clears them.
                 CodePushUtils.log("Unable to put the restored bundle in place of the patch.");
-                return BinaryPatchResult.failure(BinaryPatchResult.REASON_PATCH_APPLY_FAILED);
+                return ArchiveRestoreResult.failure(ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED);
             }
 
-            return BinaryPatchResult.success();
+            return ArchiveRestoreResult.success();
         } finally {
             FileUtils.deleteDirectoryAtPath(workingFolderPath);
         }
@@ -234,8 +234,8 @@ public class CodePushBinaryPatch {
 
     private static String reasonForResultCode(int resultCode) {
         return resultCode == PatchApplier.RESULT_UNSUPPORTED_COMPRESSION
-                ? BinaryPatchResult.REASON_UNSUPPORTED_FORMAT
-                : BinaryPatchResult.REASON_PATCH_APPLY_FAILED;
+                ? ArchiveRestoreResult.REASON_UNSUPPORTED_FORMAT
+                : ArchiveRestoreResult.REASON_PATCH_APPLY_FAILED;
     }
 
     /** Rename, falling back to a copy for the case where the two paths are on different volumes. */

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

@@ -1,6 +1,7 @@
 package com.microsoft.codepush.react;
 
 public class CodePushConstants {
+    public static final String ASSET_DIFF_DOWNLOAD_URL_KEY = "assetDiffDownloadUrl";
     public static final String ASSETS_BUNDLE_PREFIX = "assets://";
     // The binary patch values below are the client half of the contract the CLI writes
     // into a patch archive. The CLI is TypeScript, so its constants cannot be imported
@@ -23,7 +24,7 @@ public class CodePushConstants {
     public static final long BINARY_PATCH_MAX_TARGET_BUNDLE_SIZE = 128L * 1024 * 1024;
     // Not part of the CLI's contract: the field a download that tried a patch reports its
     // outcome under, on the package it resolves with and on no package it stores.
-    public static final String BINARY_PATCH_RESULT_KEY = "binaryPatchResult";
+    public static final String UPDATE_ARCHIVE_RESULT_KEY = "updateArchiveResult";
     public static final String BINARY_PATCH_TARGET_BUNDLE_HASH_KEY = "targetBundleHash";
     public static final String BINARY_PATCH_TARGET_BUNDLE_SIZE_KEY = "targetBundleSize";
     public static final String BINARY_PATCH_TARGET_FILE_NAME = "target.bundle";
@@ -35,6 +36,24 @@ public class CodePushConstants {
     public static final String DEFAULT_JS_BUNDLE_NAME = "index.android.bundle";
     public static final String DIFF_MANIFEST_FILE_NAME = "hotcodepush.json";
     public static final int DOWNLOAD_BUFFER_SIZE = 1024 * 256;
+
+    /**
+     * How long a download waits for the server to answer at all.
+     *
+     * Kept well above any real handshake, because the only thing this has to catch is a
+     * host that will never answer - a captive portal, a dead route, a network that went
+     * away between the update check and the download.
+     */
+    public static final int DOWNLOAD_CONNECT_TIMEOUT_IN_MS = 10 * 1000;
+
+    /**
+     * How long a download waits for the next bytes of a response already flowing.
+     *
+     * This bounds silence, not the download: a slow connection that keeps delivering is
+     * never cut off, however long the whole archive takes. A connection that delivers
+     * nothing for this long is one the operating system has stopped reporting as dead.
+     */
+    public static final int DOWNLOAD_READ_TIMEOUT_IN_MS = 30 * 1000;
     public static final String DOWNLOAD_FILE_NAME = "download.zip";
     public static final String DOWNLOAD_PROGRESS_EVENT_NAME = "CodePushDownloadProgress";
     public static final String DOWNLOAD_URL_KEY = "downloadUrl";