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

package/README.md

@@ -304,8 +304,10 @@ Please refer to the [CodePushOptions](https://github.com/Soomgo-Mobile/react-nat
 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 it on `CodePush({ ... })` like the callbacks above and it covers every sync, whatever the `checkFrequency` is
+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

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

@@ -338,7 +338,6 @@ public class CodePushNativeModule extends NativeCodePushSpec {
                     JSONObject mutableUpdatePackage = CodePushUtils.convertReadableToJsonObject(updatePackage);
                     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
@@ -347,16 +346,21 @@ public class CodePushNativeModule extends NativeCodePushSpec {
                                     }
                                 });
 
+                        @Override
+                        public void onDownloadStart() {
+                            progressEventDispatcher.reset();
+                        }
+
                         @Override
                         public void call(DownloadProgress downloadProgress) {
                             if (!notifyProgress || downloadProgress == null) {
                                 return;
                             }
 
-                            latestDownloadProgress = downloadProgress;
+                            progressEventDispatcher.record(downloadProgress);
                             // If the download is completed, synchronously send the last event.
                             if (downloadProgress.isCompleted()) {
-                                progressEventDispatcher.dispatch(downloadProgress);
+                                progressEventDispatcher.dispatchLatest();
                                 return;
                             }
 
@@ -372,7 +376,7 @@ public class CodePushNativeModule extends NativeCodePushSpec {
                                         @Override
                                         public void doFrame(long frameTimeNanos) {
                                             try {
-                                                progressEventDispatcher.dispatch(latestDownloadProgress);
+                                                progressEventDispatcher.dispatchLatest();
                                             } finally {
                                                 hasScheduledNextFrame = false;
                                             }

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

@@ -275,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);

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/test/java/com/microsoft/codepush/react/CodePushUpdateManagerBinaryPatchTest.java

@@ -146,6 +146,10 @@ public class CodePushUpdateManagerBinaryPatchTest {
 
     private static DownloadProgressCallback ignoreProgress() {
         return new DownloadProgressCallback() {
+            @Override
+            public void onDownloadStart() {
+            }
+
             @Override
             public void call(DownloadProgress downloadProgress) {
             }

package/android/app/src/test/java/com/microsoft/codepush/react/CodePushUpdateManagerDownloadTest.java

@@ -161,6 +161,42 @@ public class CodePushUpdateManagerDownloadTest {
         assertFallbackResult(patchResult, BinaryPatchResult.REASON_PACKAGE_VERIFICATION_FAILED);
     }
 
+    @Test
+    public void announcesEachDownloadOfAFallbackAsItsOwnProgressStream() throws IOException {
+        byte[] fullArchive = zipOf(fullArchiveContents());
+        String patchUrl = serve("/patch.zip", ERROR_PAGE);
+        String fullUrl = serve("/full.zip", fullArchive);
+        final List<List<Long>> streams = new ArrayList<>();
+        final List<Long> completedBytes = new ArrayList<>();
+
+        updateManager(applierWriting(TARGET_BUNDLE)).downloadPackage(
+                updatePackage(fullUrl, patchUrl), BUNDLE_FILE_NAME, new DownloadProgressCallback() {
+                    @Override
+                    public void onDownloadStart() {
+                        streams.add(new ArrayList<Long>());
+                    }
+
+                    @Override
+                    public void call(DownloadProgress downloadProgress) {
+                        streams.get(streams.size() - 1).add(downloadProgress.getReceivedBytes());
+                        if (downloadProgress.isCompleted()) {
+                            completedBytes.add(downloadProgress.getReceivedBytes());
+                        }
+                    }
+                });
+
+        assertEquals("each download announces a stream of its own", 2, streams.size());
+        for (List<Long> stream : streams) {
+            assertEquals("a stream opens by putting its total on the table at zero received",
+                    Long.valueOf(0), stream.get(0));
+            for (int i = 1; i < stream.size(); i++) {
+                assertTrue("a stream never runs backwards", stream.get(i) >= stream.get(i - 1));
+            }
+        }
+        assertEquals("both downloads complete at the size of the body they served",
+                Arrays.asList((long) ERROR_PAGE.length, (long) fullArchive.length), completedBytes);
+    }
+
     /** The result of a download the update had to be downloaded in full for. */
     private static void assertFallbackResult(JSONObject patchResult, String expectedReason) {
         assertEquals("fallback", patchResult.optString("status", null));
@@ -393,6 +429,10 @@ public class CodePushUpdateManagerDownloadTest {
 
     private static DownloadProgressCallback ignoreProgress() {
         return new DownloadProgressCallback() {
+            @Override
+            public void onDownloadStart() {
+            }
+
             @Override
             public void call(DownloadProgress downloadProgress) {
             }

package/android/app/src/test/java/com/microsoft/codepush/react/DownloadProgressEventDispatcherTest.java

@@ -0,0 +1,80 @@
+package com.microsoft.codepush.react;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * The dispatcher is the seam between the download thread and the UI frame callback. These
+ * pin the property the two threads rely on: per download, the JS side sees one monotonic
+ * stream, and after a reset the next download's stream starts fresh instead of being
+ * mistaken for the previous one running backwards.
+ */
+public class DownloadProgressEventDispatcherTest {
+
+    private final List<Long> mEmittedBytes = new ArrayList<>();
+    private final DownloadProgressEventDispatcher mDispatcher = new DownloadProgressEventDispatcher(
+            new DownloadProgressEventDispatcher.EventEmitter() {
+                @Override
+                public void emit(DownloadProgress downloadProgress) {
+                    mEmittedBytes.add(downloadProgress.getReceivedBytes());
+                }
+            });
+
+    @Test
+    public void aFrameCallbackWithNothingRecordedEmitsNothing() {
+        mDispatcher.dispatchLatest();
+
+        assertEquals(Collections.emptyList(), mEmittedBytes);
+    }
+
+    @Test
+    public void emitsOnlyTheLatestRecordedProgress() {
+        mDispatcher.record(new DownloadProgress(100, 60));
+        mDispatcher.record(new DownloadProgress(100, 80));
+
+        mDispatcher.dispatchLatest();
+
+        assertEquals(Arrays.asList(80L), mEmittedBytes);
+    }
+
+    @Test
+    public void aFrameCallbackFiringAfterTheCompletionEventEmitsNothingMore() {
+        mDispatcher.record(new DownloadProgress(100, 90));
+        mDispatcher.dispatchLatest();
+        mDispatcher.record(new DownloadProgress(100, 100));
+        mDispatcher.dispatchLatest();
+
+        // The frame callback that was already scheduled when the download completed.
+        mDispatcher.dispatchLatest();
+
+        assertEquals(Arrays.asList(90L, 100L), mEmittedBytes);
+    }
+
+    @Test
+    public void aResetLetsTheNextDownloadCountFromZeroAgain() {
+        mDispatcher.record(new DownloadProgress(100, 100));
+        mDispatcher.dispatchLatest();
+
+        mDispatcher.reset();
+        mDispatcher.record(new DownloadProgress(5000, 10));
+        mDispatcher.dispatchLatest();
+
+        assertEquals(Arrays.asList(100L, 10L), mEmittedBytes);
+    }
+
+    @Test
+    public void progressRecordedBeforeAResetIsNotEmittedAfterIt() {
+        mDispatcher.record(new DownloadProgress(100, 100));
+
+        mDispatcher.reset();
+        mDispatcher.dispatchLatest();
+
+        assertEquals(Collections.emptyList(), mEmittedBytes);
+    }
+}

package/cli/dist/functions/runExpoBundleCommand.js

@@ -24,6 +24,10 @@ export function runExpoBundleCommand(bundleName, outputPath, platform, sourcemap
         'false',
         '--entry-file',
         entryFile,
+        // Same reason as `runReactNativeBundleCommand`: the native build embeds an
+        // unminified bundle, and diverging from it inflates every binary patch.
+        '--minify',
+        'false',
         '--platform',
         platform,
         '--sourcemap-output',

package/cli/dist/functions/runReactNativeBundleCommand.js

@@ -28,6 +28,16 @@ export function runReactNativeBundleCommand(bundleName, outputPath, platform, so
         'false',
         '--entry-file',
         entryFile,
+        /**
+         * Match React Native's Hermes builds, which disable JS minification. Minifying an
+         * update barely changes how large its bytecode is, but it changes how that bytecode
+         * is laid out - enough that a binary patch against an unminified binary costs far
+         * more than the source change does.
+         *
+         * Listed before the caller's options so an explicit `--minify` still wins.
+         */
+        '--minify',
+        'false',
         '--platform',
         platform,
         '--sourcemap-output',

package/cli/functions/runExpoBundleCommand.ts

@@ -32,6 +32,10 @@ export function runExpoBundleCommand(
         'false',
         '--entry-file',
         entryFile,
+        // Same reason as `runReactNativeBundleCommand`: the native build embeds an
+        // unminified bundle, and diverging from it inflates every binary patch.
+        '--minify',
+        'false',
         '--platform',
         platform,
         '--sourcemap-output',

package/cli/functions/runReactNativeBundleCommand.ts

@@ -38,6 +38,16 @@ export function runReactNativeBundleCommand(
         'false',
         '--entry-file',
         entryFile,
+        /**
+         * Match React Native's Hermes builds, which disable JS minification. Minifying an
+         * update barely changes how large its bytecode is, but it changes how that bytecode
+         * is laid out - enough that a binary patch against an unminified binary costs far
+         * more than the source change does.
+         *
+         * Listed before the caller's options so an explicit `--minify` still wins.
+         */
+        '--minify',
+        'false',
         '--platform',
         platform,
         '--sourcemap-output',

package/ios/CodePush/CodePush.mm

@@ -739,6 +739,14 @@ RCT_EXPORT_METHOD(downloadUpdate:(NSDictionary*)updatePackage
         operationQueue:_methodQueue
         // The download is progressing forward
         progressCallback:^(long long expectedContentLength, long long receivedContentLength) {
+            // Received bytes only run backwards when a new download starts a stream of its
+            // own - the full archive after a binary patch fallback. The pause left over
+            // from the finished patch download would swallow that whole stream, so frame
+            // observation resumes here and the throttle forgets the previous stream.
+            if (notifyProgress && receivedContentLength < _latestReceivedConentLength) {
+                self.paused = NO;
+                _lastProgressEventTime = 0;
+            }
             // Update the download progress so that the frame observer can notify the JS side
             _latestExpectedContentLength = expectedContentLength;
             _latestReceivedConentLength = receivedContentLength;

package/ios/CodePush/CodePushDownloadHandler.m

@@ -61,6 +61,12 @@ failCallback:(void (^)(NSError *err))failCallback {
     }
     
     self.expectedContentLength = response.expectedContentLength;
+    if (self.expectedContentLength > 0) {
+        // Each download opens its own progress stream. The zero-received event hands the
+        // listener the new total up front, so the full download after a binary patch
+        // fallback shows as restarting rather than running backwards.
+        self.progressCallback(self.expectedContentLength, 0);
+    }
     [self.outputFileStream open];
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bravemobile/react-native-code-push",
-  "version": "13.1.0-beta.0",
+  "version": "13.1.0-beta.2",
   "description": "React Native plugin for the CodePush service",
   "main": "src/CodePush.js",
   "react-native": "src/CodePush.js",

package/typings/react-native-code-push.d.ts

@@ -162,7 +162,9 @@ export interface CodePushOptions extends SyncOptions {
 
 export interface DownloadProgress {
     /**
-     * The total number of bytes expected to be received for this update.
+     * The total number of bytes expected to be received for this download. An update
+     * published with a binary patch can be downloaded twice: when applying the patch
+     * fails, the full archive is downloaded as a second stream with its own total.
      */
     totalBytes: number;