@bravemobile/react-native-code-push 12.4.1 → 13.1.0-beta.0

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

@@ -2,7 +2,6 @@ package com.microsoft.codepush.react;
 
 import android.app.Activity;
 import android.content.SharedPreferences;
-import android.os.AsyncTask;
 import android.os.Handler;
 import android.os.Looper;
 import android.view.View;
@@ -20,11 +19,11 @@ import com.facebook.react.bridge.JSBundleLoader;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.annotations.UnstableReactNativeAPI;
+import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.runtime.ReactHostDelegate;
@@ -37,15 +36,19 @@ import java.io.IOException;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@ReactModule(name = CodePushNativeModule.NAME)
+public class CodePushNativeModule extends NativeCodePushSpec {
+    public static final String NAME = "CodePush";
 
-public class CodePushNativeModule extends ReactContextBaseJavaModule {
     private String mBinaryContentsHash = null;
     private String mClientUniqueId = null;
     private LifecycleEventListener mLifecycleEventListener = null;
     private int mMinimumBackgroundDuration = 0;
+    private final ExecutorService mBackgroundExecutor = Executors.newSingleThreadExecutor();
 
     private CodePush mCodePush;
     private SettingsManager mSettingsManager;
@@ -76,24 +79,15 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     @Override
-    public Map<String, Object> getConstants() {
-        final Map<String, Object> constants = new HashMap<>();
-
-        constants.put("codePushInstallModeImmediate", CodePushInstallMode.IMMEDIATE.getValue());
-        constants.put("codePushInstallModeOnNextRestart", CodePushInstallMode.ON_NEXT_RESTART.getValue());
-        constants.put("codePushInstallModeOnNextResume", CodePushInstallMode.ON_NEXT_RESUME.getValue());
-        constants.put("codePushInstallModeOnNextSuspend", CodePushInstallMode.ON_NEXT_SUSPEND.getValue());
-
-        constants.put("codePushUpdateStateRunning", CodePushUpdateState.RUNNING.getValue());
-        constants.put("codePushUpdateStatePending", CodePushUpdateState.PENDING.getValue());
-        constants.put("codePushUpdateStateLatest", CodePushUpdateState.LATEST.getValue());
-
-        return constants;
+    public String getName() {
+        return NAME;
     }
 
     @Override
-    public String getName() {
-        return "CodePush";
+    public void invalidate() {
+        clearLifecycleEventListener();
+        mBackgroundExecutor.shutdownNow();
+        super.invalidate();
     }
 
     private void loadBundleLegacy() {
@@ -265,6 +259,21 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
         return null;
     }
 
+    private void executeInBackground(Runnable runnable) {
+        mBackgroundExecutor.execute(runnable);
+    }
+
+    private void emitDownloadProgressEvent(DownloadProgress downloadProgress) {
+        if (mEventEmitterCallback != null) {
+            emitOnDownloadProgress(downloadProgress.createWritableMap());
+            return;
+        }
+
+        getReactApplicationContext()
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(CodePushConstants.DOWNLOAD_PROGRESS_EVENT_NAME, downloadProgress.createWritableMap());
+    }
+
     private void restartAppInternal(boolean onlyIfUpdateIsPending) {
         if (this._restartInProgress) {
             CodePushUtils.log("Restart request queued until the current restart is completed");
@@ -292,7 +301,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void allow(Promise promise) {
+    public void allow() {
         CodePushUtils.log("Re-allowing restarts");
         this._allowed = true;
 
@@ -302,54 +311,39 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
             this._restartQueue.remove(0);
             this.restartAppInternal(buf);
         }
-
-        promise.resolve(null);
-        return;
     }
 
     @ReactMethod
-    public void clearPendingRestart(Promise promise) {
+    public void clearPendingRestart() {
         this._restartQueue.clear();
-        promise.resolve(null);
-        return;
     }
 
     @ReactMethod
-    public void disallow(Promise promise) {
+    public void disallow() {
         CodePushUtils.log("Disallowing restarts");
         this._allowed = false;
-        promise.resolve(null);
-        return;
     }
 
     @ReactMethod
-    public void restartApp(boolean onlyIfUpdateIsPending, Promise promise) {
-        try {
-            restartAppInternal(onlyIfUpdateIsPending);
-            promise.resolve(null);
-        } catch(CodePushUnknownException e) {
-            CodePushUtils.log(e);
-            promise.reject(e);
-        }
+    public void restartApp(boolean onlyIfUpdateIsPending) {
+        restartAppInternal(onlyIfUpdateIsPending);
     }
 
     @ReactMethod
     public void downloadUpdate(final ReadableMap updatePackage, final boolean notifyProgress, final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
                     JSONObject mutableUpdatePackage = CodePushUtils.convertReadableToJsonObject(updatePackage);
-                    mUpdateManager.downloadPackage(mutableUpdatePackage, mCodePush.getAssetsBundleFileName(), new DownloadProgressCallback() {
+                    JSONObject binaryPatchResult = mUpdateManager.downloadPackage(mutableUpdatePackage, mCodePush.getAssetsBundleFileName(), new DownloadProgressCallback() {
                         private volatile boolean hasScheduledNextFrame = false;
                         private volatile DownloadProgress latestDownloadProgress = null;
                         private final DownloadProgressEventDispatcher progressEventDispatcher = new DownloadProgressEventDispatcher(
                                 new DownloadProgressEventDispatcher.EventEmitter() {
                                     @Override
                                     public void emit(DownloadProgress downloadProgress) {
-                                        getReactApplicationContext()
-                                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                                                .emit(CodePushConstants.DOWNLOAD_PROGRESS_EVENT_NAME, downloadProgress.createWritableMap());
+                                        emitDownloadProgressEvent(downloadProgress);
                                     }
                                 });
 
@@ -390,7 +384,17 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     });
 
                     JSONObject newPackage = mUpdateManager.getPackage(CodePushUtils.tryGetString(updatePackage, CodePushConstants.PACKAGE_HASH_KEY));
-                    promise.resolve(CodePushUtils.convertJsonObjectToWritable(newPackage));
+                    WritableMap downloadedPackage = CodePushUtils.convertJsonObjectToWritable(newPackage);
+                    if (binaryPatchResult != null) {
+                        // The result describes this download rather than the update, so it is
+                        // put on what this call resolves with and nowhere else: the metadata
+                        // the update manager has already written knows nothing about it, and
+                        // whoever asked for the download decides what the result is worth.
+                        downloadedPackage.putMap(CodePushConstants.BINARY_PATCH_RESULT_KEY,
+                                CodePushUtils.convertJsonObjectToWritable(binaryPatchResult));
+                    }
+
+                    promise.resolve(downloadedPackage);
                 } catch (CodePushInvalidUpdateException e) {
                     CodePushUtils.log(e);
                     mSettingsManager.saveFailedUpdate(CodePushUtils.convertReadableToJsonObject(updatePackage));
@@ -399,12 +403,8 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
@@ -429,16 +429,17 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void getUpdateMetadata(final int updateState, final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+    public void getUpdateMetadata(final double updateStateValue, final Promise promise) {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
+                    int updateState = (int) updateStateValue;
                     JSONObject currentPackage = mUpdateManager.getCurrentPackage();
 
                     if (currentPackage == null) {
                         promise.resolve(null);
-                        return null;
+                        return;
                     }
 
                     Boolean currentUpdateIsPending = false;
@@ -459,7 +460,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
 
                         if (previousPackage == null) {
                             promise.resolve(null);
-                            return null;
+                            return;
                         }
 
                         promise.resolve(CodePushUtils.convertJsonObjectToWritable(previousPackage));
@@ -488,19 +489,15 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
     public void getNewStatusReport(final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
                     if (mCodePush.needToReportRollback()) {
                         mCodePush.setNeedToReportRollback(false);
@@ -512,7 +509,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                                 WritableMap failedStatusReport = mTelemetryManager.getRollbackReport(lastFailedPackage);
                                 if (failedStatusReport != null) {
                                     promise.resolve(failedStatusReport);
-                                    return null;
+                                    return;
                                 }
                             } catch (JSONException e) {
                                 throw new CodePushUnknownException("Unable to read failed updates information stored in SharedPreferences.", e);
@@ -524,41 +521,40 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                             WritableMap newPackageStatusReport = mTelemetryManager.getUpdateReport(CodePushUtils.convertJsonObjectToWritable(currentPackage));
                             if (newPackageStatusReport != null) {
                                 promise.resolve(newPackageStatusReport);
-                                return null;
+                                return;
                             }
                         }
                     } else if (mCodePush.isRunningBinaryVersion()) {
                         WritableMap newAppVersionStatusReport = mTelemetryManager.getBinaryUpdateReport(mCodePush.getAppVersion());
                         if (newAppVersionStatusReport != null) {
                             promise.resolve(newAppVersionStatusReport);
-                            return null;
+                            return;
                         }
                     } else {
                         WritableMap retryStatusReport = mTelemetryManager.getRetryStatusReport();
                         if (retryStatusReport != null) {
                             promise.resolve(retryStatusReport);
-                            return null;
+                            return;
                         }
                     }
 
-                    promise.resolve("");
+                    promise.resolve(null);
                 } catch(CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
-    public void installUpdate(final ReadableMap updatePackage, final int installMode, final int minimumBackgroundDuration, final Promise promise) {
-        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+    public void installUpdate(final ReadableMap updatePackage, final double installModeValue, final double minimumBackgroundDurationValue, final Promise promise) {
+        executeInBackground(new Runnable() {
             @Override
-            protected Void doInBackground(Void... params) {
+            public void run() {
                 try {
+                    int installMode = (int) installModeValue;
+                    int minimumBackgroundDuration = (int) minimumBackgroundDurationValue;
                     mUpdateManager.installPackage(CodePushUtils.convertReadableToJsonObject(updatePackage), mSettingsManager.isPendingUpdate(null));
 
                     String pendingHash = CodePushUtils.tryGetString(updatePackage, CodePushConstants.PACKAGE_HASH_KEY);
@@ -568,13 +564,12 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                         mSettingsManager.savePendingUpdate(pendingHash, /* isLoading */false);
                     }
 
-                    if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue() ||
-                        // We also add the resume listener if the installMode is IMMEDIATE, because
-                        // if the current activity is backgrounded, we want to reload the bundle when
-                        // it comes back into the foreground.
-                        installMode == CodePushInstallMode.IMMEDIATE.getValue() ||
-                        installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
-
+                    if (installMode == CodePushInstallMode.ON_NEXT_RESUME.getValue()
+                            // We also add the resume listener if the installMode is IMMEDIATE, because
+                            // if the current activity is backgrounded, we want to reload the bundle when
+                            // it comes back into the foreground.
+                            || installMode == CodePushInstallMode.IMMEDIATE.getValue()
+                            || installMode == CodePushInstallMode.ON_NEXT_SUSPEND.getValue()) {
                         // Store the minimum duration on the native module as an instance
                         // variable instead of relying on a closure below, so that any
                         // subsequent resume-based installs could override it.
@@ -628,17 +623,13 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                         }
                     }
 
-                    promise.resolve("");
+                    promise.resolve(null);
                 } catch(CodePushUnknownException e) {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
@@ -695,7 +686,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
     public void notifyApplicationReady(Promise promise) {
         try {
             mSettingsManager.removePendingUpdate();
-            promise.resolve("");
+            promise.resolve(null);
         } catch(CodePushUnknownException e) {
             CodePushUtils.log(e);
             promise.reject(e);

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

@@ -1,14 +1,17 @@
 package com.microsoft.codepush.react;
 
+import android.content.Context;
 import android.os.Build;
 
 import org.json.JSONObject;
 
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -19,9 +22,15 @@ import javax.net.ssl.HttpsURLConnection;
 public class CodePushUpdateManager {
 
     private String mDocumentsDirectory;
+    private final CodePushBinaryPatch mBinaryPatch;
 
-    public CodePushUpdateManager(String documentsDirectory) {
+    public CodePushUpdateManager(String documentsDirectory, Context context) {
+        this(documentsDirectory, new CodePushBinaryPatch(new AssetsBaseBundleProvider(context), new HDiffPatchNative()));
+    }
+
+    CodePushUpdateManager(String documentsDirectory, CodePushBinaryPatch binaryPatch) {
         mDocumentsDirectory = documentsDirectory;
+        mBinaryPatch = binaryPatch;
     }
 
     private String getDownloadFilePath() {
@@ -32,6 +41,10 @@ public class CodePushUpdateManager {
         return CodePushUtils.appendPathComponent(getCodePushPath(), CodePushConstants.UNZIPPED_FOLDER_NAME);
     }
 
+    private String getBinaryPatchFolderPath() {
+        return CodePushUtils.appendPathComponent(getCodePushPath(), CodePushConstants.BINARY_PATCH_FOLDER_NAME);
+    }
+
     private String getDocumentsDirectory() {
         return mDocumentsDirectory;
     }
@@ -143,8 +156,92 @@ public class CodePushUpdateManager {
         }
     }
 
-    public void downloadPackage(JSONObject updatePackage, String expectedBundleFileName,
-                                DownloadProgressCallback progressCallback) throws IOException {
+    /**
+     * @return what the attempt at installing the update from its binary patch archive ended
+     *         in, or null when the update had no patch archive to attempt. The result belongs
+     *         to this download alone: the metadata written for the update never carries it.
+     */
+    public JSONObject downloadPackage(JSONObject updatePackage, String expectedBundleFileName,
+                                      DownloadProgressCallback progressCallback) throws IOException {
+        // A release that was published with a binary patch offers two archives of the same
+        // update. The patch is worth trying because it is a fraction of the size, and the
+        // full archive is always there when it does not work out.
+        String binaryPatchDownloadUrl = updatePackage.optString(CodePushConstants.BINARY_PATCH_DOWNLOAD_URL_KEY, null);
+        BinaryPatchAttempt patchAttempt = null;
+        if (binaryPatchDownloadUrl != null) {
+            patchAttempt = new BinaryPatchAttempt();
+            if (tryDownloadBinaryPatchPackage(updatePackage, expectedBundleFileName, progressCallback,
+                    binaryPatchDownloadUrl, patchAttempt)) {
+                return patchAttempt.result();
+            }
+        }
+
+        downloadAndInstallPackage(updatePackage, expectedBundleFileName, progressCallback,
+                updatePackage.optString(CodePushConstants.DOWNLOAD_URL_KEY, null), false, null);
+
+        return patchAttempt == null ? null : patchAttempt.result();
+    }
+
+    /**
+     * Installs the update from its binary patch archive.
+     *
+     * Every way this can fail ends the same way, with the update being downloaded in full
+     * instead, so none of them is reported to the caller as an error. The fallback happens
+     * exactly once without anything having to count it: the full archive is downloaded by
+     * a call that is not allowed to take the patch path, so it has no failure of its own to
+     * fall back from.
+     *
+     * @param patchAttempt records what the attempt ended in, for the caller to hand to
+     *                     whoever asked for the download
+     * @return true when the update was installed, false when the caller has to download the
+     *         full archive instead
+     */
+    private boolean tryDownloadBinaryPatchPackage(JSONObject updatePackage, String expectedBundleFileName,
+                                                  DownloadProgressCallback progressCallback,
+                                                  String binaryPatchDownloadUrl, BinaryPatchAttempt patchAttempt) {
+        try {
+            BinaryPatchResult patchResult = downloadAndInstallPackage(updatePackage, expectedBundleFileName,
+                    progressCallback, binaryPatchDownloadUrl, true, patchAttempt);
+            if (patchResult.succeeded()) {
+                return true;
+            }
+
+            patchAttempt.recordFallback(patchResult.getFailureReason());
+            CodePushUtils.log("Binary patch update failed (" + patchResult.getFailureReason()
+                    + "). Downloading the full update instead.");
+        } catch (Exception | OutOfMemoryError e) {
+            // Applying a patch is the one path that holds a whole bundle in memory, so
+            // running out of it is a failure this has to absorb like any other: by the time
+            // it lands here the arrays are unreachable, and the full archive is downloaded
+            // to disk in chunks rather than held.
+            patchAttempt.recordFallbackAfterError();
+            CodePushUtils.log(e);
+            CodePushUtils.log("The binary patch update could not be completed. Downloading the full update instead.");
+        } finally {
+            FileUtils.deleteDirectoryAtPath(getBinaryPatchFolderPath());
+        }
+
+        return false;
+    }
+
+    /**
+     * Downloads an update from one of its archives and installs it.
+     *
+     * @param isBinaryPatchUpdate whether the archive holds a binary patch of the JS bundle,
+     *                            which has to be applied before the contents are the update.
+     *                            Only an archive downloaded from the binary patch URL is
+     *                            treated that way, so an update being downloaded in full can
+     *                            never end up on the patch path.
+     * @param patchAttempt the record the patch is timed into, or null for a full download,
+     *                     which has no patch to time
+     * @return the outcome of the patch: a failed result means the update was not installed
+     *         and the caller has to fall back to the full archive. Downloading the full
+     *         archive always succeeds or throws.
+     */
+    BinaryPatchResult downloadAndInstallPackage(JSONObject updatePackage, String expectedBundleFileName,
+                                                DownloadProgressCallback progressCallback,
+                                                String downloadUrlString, boolean isBinaryPatchUpdate,
+                                                BinaryPatchAttempt patchAttempt) throws IOException {
         String newUpdateHash = updatePackage.optString(CodePushConstants.PACKAGE_HASH_KEY, null);
         String newUpdateFolderPath = getPackageFolderPath(newUpdateHash);
         String newUpdateMetadataPath = CodePushUtils.appendPathComponent(newUpdateFolderPath, CodePushConstants.PACKAGE_FILE_NAME);
@@ -154,7 +251,6 @@ public class CodePushUpdateManager {
             FileUtils.deleteDirectoryAtPath(newUpdateFolderPath);
         }
 
-        String downloadUrlString = updatePackage.optString(CodePushConstants.DOWNLOAD_URL_KEY, null);
         HttpURLConnection connection = null;
         BufferedInputStream bin = null;
         FileOutputStream fos = null;
@@ -232,6 +328,21 @@ public class CodePushUpdateManager {
             FileUtils.unzipFile(downloadFile, unzippedFolderPath);
             FileUtils.deleteFileOrFolderSilently(downloadFile);
 
+            // Rebuild the JS bundle the archive only carries a patch of, which leaves the
+            // contents identical to the ones the full archive would have delivered.
+            if (isBinaryPatchUpdate) {
+                long patchStartTime = System.currentTimeMillis();
+                BinaryPatchResult patchResult = mBinaryPatch.restoreBundle(unzippedFolderPath,
+                        getBinaryPatchFolderPath(), expectedBundleFileName);
+                if (!patchResult.succeeded()) {
+                    return patchResult;
+                }
+
+                long applyDurationMs = System.currentTimeMillis() - patchStartTime;
+                patchAttempt.recordBundleRestored(applyDurationMs);
+                CodePushUtils.log("Restored the update from its binary patch in " + applyDurationMs + " ms.");
+            }
+
             // Merge contents with current update based on the manifest
             String diffManifestFilePath = CodePushUtils.appendPathComponent(unzippedFolderPath,
                     CodePushConstants.DIFF_MANIFEST_FILE_NAME);
@@ -268,12 +379,22 @@ public class CodePushUpdateManager {
                 CodePushUtils.setJSONValueForKey(updatePackage, CodePushConstants.RELATIVE_BUNDLE_PATH_KEY, relativeBundlePath);
             }
         } else {
+            if (isBinaryPatchUpdate) {
+                // Whatever the patch URL served, it is not a patch archive - an error page
+                // answered with a 200 looks like this too. Moving it into place would
+                // install bytes no hash has ever been checked against, so the full archive
+                // is downloaded instead.
+                return BinaryPatchResult.failure(BinaryPatchResult.REASON_INVALID_MANIFEST);
+            }
+
             // File is a jsbundle, move it to a folder with the packageHash as its name
             FileUtils.moveFile(downloadFile, newUpdateFolderPath, expectedBundleFileName);
         }
 
         // Save metadata to the folder.
         CodePushUtils.writeJsonToFile(updatePackage, newUpdateMetadataPath);
+
+        return BinaryPatchResult.success();
     }
 
     public void installPackage(JSONObject updatePackage, boolean removePendingUpdate) {
@@ -349,4 +470,38 @@ public class CodePushUpdateManager {
     public void clearUpdates() {
         FileUtils.deleteDirectoryAtPath(getCodePushPath());
     }
+
+    /** Reads the JS bundle that shipped inside the app binary out of the APK's assets. */
+    private static class AssetsBaseBundleProvider implements CodePushBinaryPatch.BaseBundleProvider {
+
+        private final Context mContext;
+
+        AssetsBaseBundleProvider(Context context) {
+            mContext = context;
+        }
+
+        @Override
+        public byte[] readBaseBundle(String bundleFileName) throws IOException {
+            // The bundle is stored uncompressed in the APK, so it is read straight into
+            // memory: a copy on disk would buy nothing and cost the space the restored
+            // bundle needs.
+            InputStream assetStream = mContext.getAssets().open(bundleFileName);
+            try {
+                // An uncompressed asset knows its whole length up front, so the buffer is
+                // sized for it: growing one would repeatedly hold two copies of a bundle
+                // that is already the largest allocation on this path.
+                ByteArrayOutputStream bundleBytes = new ByteArrayOutputStream(
+                        Math.max(assetStream.available(), CodePushConstants.DOWNLOAD_BUFFER_SIZE));
+                byte[] buffer = new byte[CodePushConstants.DOWNLOAD_BUFFER_SIZE];
+                int bytesRead;
+                while ((bytesRead = assetStream.read(buffer)) > 0) {
+                    bundleBytes.write(buffer, 0, bytesRead);
+                }
+
+                return bundleBytes.toByteArray();
+            } finally {
+                assetStream.close();
+            }
+        }
+    }
 }

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

@@ -86,6 +86,19 @@ public class CodePushUpdateUtils {
         return String.format("%064x", new java.math.BigInteger(1, hash));
     }
 
+    /**
+     * SHA-256 of a single file's bytes, as lowercase hex - the way a binary patch manifest
+     * records the bundle it was computed against and the bundle it produces.
+     */
+    public static String computeHashForFile(File file) throws IOException {
+        return computeHash(new FileInputStream(file));
+    }
+
+    /** SHA-256 of the bytes in memory, in the same form as {@link #computeHashForFile}. */
+    public static String computeHashForBytes(byte[] data) {
+        return computeHash(new ByteArrayInputStream(data));
+    }
+
     public static void copyNecessaryFilesFromCurrentPackage(String diffManifestFilePath, String currentPackageFolderPath, String newPackageFolderPath) throws IOException {
         if (currentPackageFolderPath == null || !new File(currentPackageFolderPath).exists()) {
             CodePushUtils.log("Unable to copy files from current package during diff update, because currentPackageFolderPath is invalid.");

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

@@ -0,0 +1,52 @@
+package com.microsoft.codepush.react;
+
+/**
+ * The native HDiffPatch applier, which is what actually turns the bundle inside the app
+ * binary into the bundle an update wants to run.
+ *
+ * The library is loaded on first use rather than when the class is loaded, and a load
+ * failure is reported as a result code instead of an error: an app whose build did not
+ * produce the library still has to install its updates, it just has to download them in
+ * full.
+ */
+public class HDiffPatchNative implements CodePushBinaryPatch.PatchApplier {
+
+    private static final String LIBRARY_NAME = "codepush-binarypatch";
+
+    private static boolean sLibraryLoadAttempted = false;
+    private static boolean sLibraryLoaded = false;
+
+    @Override
+    public int apply(byte[] base, byte[] patch, String outputPath, long expectedTargetSize) {
+        if (!loadLibrary()) {
+            return RESULT_LIBRARY_UNAVAILABLE;
+        }
+
+        return applyPatch(base, patch, outputPath, expectedTargetSize);
+    }
+
+    private static synchronized boolean loadLibrary() {
+        if (!sLibraryLoadAttempted) {
+            sLibraryLoadAttempted = true;
+            try {
+                System.loadLibrary(LIBRARY_NAME);
+                sLibraryLoaded = true;
+            } catch (UnsatisfiedLinkError e) {
+                CodePushUtils.log("Unable to load the binary patch library: " + e.getMessage());
+            }
+        }
+
+        return sLibraryLoaded;
+    }
+
+    /**
+     * Writes the bundle that `patch` produces from `base` to `outputPath`.
+     *
+     * The base bundle and the patch are passed as arrays because the applier needs random
+     * access to both, while the restored bundle is written straight to a file, so the two
+     * bundles are never in memory at the same time.
+     *
+     * @return one of the RESULT_* codes of {@link CodePushBinaryPatch.PatchApplier}
+     */
+    private static native int applyPatch(byte[] base, byte[] patch, String outputPath, long expectedTargetSize);
+}