@bravemobile/react-native-code-push 13.0.0 → 13.1.0-beta.1

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;
@@ -179,9 +275,18 @@ public class CodePushUpdateManager {
             connection.setRequestProperty("Accept-Encoding", "identity");
             bin = new BufferedInputStream(connection.getInputStream());
 
+            // Announced only once the response is flowing, so a connection that fails to
+            // open never announces an empty stream.
+            progressCallback.onDownloadStart();
             long totalBytes = connection.getContentLength();
             long receivedBytes = 0;
 
+            if (totalBytes > 0) {
+                // The zero-received event hands the listener this download's total up front,
+                // so a fallback download shows as restarting rather than running backwards.
+                progressCallback.call(new DownloadProgress(totalBytes, 0));
+            }
+
             File downloadFolder = new File(getCodePushPath());
             downloadFolder.mkdirs();
             downloadFile = new File(downloadFolder, CodePushConstants.DOWNLOAD_FILE_NAME);
@@ -232,6 +337,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 +388,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 +479,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/DownloadProgressCallback.java

@@ -1,5 +1,12 @@
 package com.microsoft.codepush.react;
 
 interface DownloadProgressCallback {
+    /**
+     * A download is starting its own progress stream: received bytes count from zero again,
+     * against this download's own total. A binary patch fallback makes this happen twice
+     * within one downloaded update.
+     */
+    void onDownloadStart();
+
     void call(DownloadProgress downloadProgress);
 }

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

@@ -1,23 +1,44 @@
 package com.microsoft.codepush.react;
 
+/**
+ * Serializes progress events from the download thread and the UI frame callback into one
+ * monotonic stream per download: whatever order the two threads dispatch in, the JS side
+ * never sees the same download run backwards. The latest progress lives here rather than
+ * with the caller so that reading it and dispatching it happen under one lock.
+ */
 class DownloadProgressEventDispatcher {
     interface EventEmitter {
         void emit(DownloadProgress downloadProgress);
     }
 
     private final EventEmitter mEventEmitter;
+    private DownloadProgress mLatestDownloadProgress = null;
     private long mLastDispatchedBytes = -1;
 
     DownloadProgressEventDispatcher(EventEmitter eventEmitter) {
         mEventEmitter = eventEmitter;
     }
 
-    synchronized void dispatch(DownloadProgress downloadProgress) {
-        if (downloadProgress == null || downloadProgress.getReceivedBytes() <= mLastDispatchedBytes) {
+    synchronized void record(DownloadProgress downloadProgress) {
+        mLatestDownloadProgress = downloadProgress;
+    }
+
+    synchronized void dispatchLatest() {
+        if (mLatestDownloadProgress == null || mLatestDownloadProgress.getReceivedBytes() <= mLastDispatchedBytes) {
             return;
         }
 
-        mEventEmitter.emit(downloadProgress);
-        mLastDispatchedBytes = downloadProgress.getReceivedBytes();
+        mEventEmitter.emit(mLatestDownloadProgress);
+        mLastDispatchedBytes = mLatestDownloadProgress.getReceivedBytes();
+    }
+
+    /**
+     * Forgets the download dispatched so far. The next download counts its bytes from zero,
+     * and without the reset the monotonic guard would swallow its events as the previous
+     * download running backwards.
+     */
+    synchronized void reset() {
+        mLatestDownloadProgress = null;
+        mLastDispatchedBytes = -1;
     }
 }

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);
+}