@bravemobile/react-native-code-push 12.4.0 → 13.0.0

package/CodePush.podspec

@@ -14,7 +14,7 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = '15.5'
   s.preserve_paths = '*.js'
   s.library        = 'z'
-  s.source_files = 'ios/CodePush/*.{h,m}'
+  s.source_files = 'ios/CodePush/*.{h,m,mm}'
   s.public_header_files = ['ios/CodePush/CodePush.h']
 
   # Note: Even though there are copy/pasted versions of some of these dependencies in the repo,
@@ -22,4 +22,17 @@ Pod::Spec.new do |s|
   # linked properly at a parent workspace level.
   s.dependency 'React-Core'
   s.dependency 'SSZipArchive', '~> 2.5.5'
+
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+    s.compiler_flags = '-DRCT_NEW_ARCH_ENABLED=1'
+    s.pod_target_xcconfig = {
+      'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+      'HEADER_SEARCH_PATHS' => "\"$(PODS_ROOT)/Headers/Public/ReactCodegen\" \"${PODS_CONFIGURATION_BUILD_DIR}/ReactCodegen/ReactCodegen.framework/Headers\""
+    }
+
+    s.dependency 'ReactCodegen'
+    s.dependency 'RCTRequired'
+    s.dependency 'RCTTypeSafety'
+    s.dependency 'ReactCommon/turbomodule/core'
+  end
 end

package/README.md

@@ -8,11 +8,14 @@
 
 ### 🚀 New Architecture support
 
-Supports React Native 0.77 ~ 0.84.
+Supports React Native 0.77 ~ 0.86.
 
 > [!NOTE]
 > If you are using React Native 0.76 or lower, please use version `12.0.2` of this library.
 
+> [!IMPORTANT]
+> `13.0.0` migrates the native module to TurboModule. A `13.0.0` binary only runs OTA bundles built with `13.0.0` or later, so ship a new binary version and start its release history fresh when you upgrade.
+
 (Tested on the React Native CLI template apps)
 
 ### ✅ Requirements

package/android/app/build.gradle

@@ -1,10 +1,17 @@
 apply plugin: "com.android.library"
+apply plugin: "com.facebook.react"
 
 def DEFAULT_COMPILE_SDK_VERSION = 26
 def DEFAULT_BUILD_TOOLS_VERSION = "26.0.3"
 def DEFAULT_TARGET_SDK_VERSION = 26
 def DEFAULT_MIN_SDK_VERSION = 16
 
+react {
+    jsRootDir = file("../..")
+    libraryName = "RNCodePushSpec"
+    codegenJavaPackageName = "com.microsoft.codepush.react"
+}
+
 android {
     namespace "com.microsoft.codepush.react"
 

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

@@ -4,18 +4,25 @@ import android.content.Context;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 
-import com.facebook.react.ReactPackage;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.uimanager.ViewManager;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-public class CodePush implements ReactPackage {
+public class CodePush extends TurboReactPackage {
 
     private static boolean sIsRunningBinaryVersion = false;
     private static boolean sNeedToReportRollback = false;
@@ -300,17 +307,45 @@ public class CodePush implements ReactPackage {
     }
 
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
-        CodePushNativeModule codePushModule = new CodePushNativeModule(reactApplicationContext, this, mUpdateManager, mTelemetryManager, mSettingsManager);
-        CodePushDialog dialogModule = new CodePushDialog(reactApplicationContext);
+    public @Nullable NativeModule getModule(String name, ReactApplicationContext reactApplicationContext) {
+        if (!CodePushNativeModule.NAME.equals(name)) {
+            return null;
+        }
+
+        return new CodePushNativeModule(
+                reactApplicationContext,
+                this,
+                mUpdateManager,
+                mTelemetryManager,
+                mSettingsManager
+        );
+    }
 
-        List<NativeModule> nativeModules = new ArrayList<>();
-        nativeModules.add(codePushModule);
-        nativeModules.add(dialogModule);
-        return nativeModules;
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return new ReactModuleInfoProvider() {
+            @Override
+            public Map<String, ReactModuleInfo> getReactModuleInfos() {
+                Map<String, ReactModuleInfo> reactModuleInfoMap = new HashMap<>();
+                reactModuleInfoMap.put(
+                        CodePushNativeModule.NAME,
+                        new ReactModuleInfo(
+                                CodePushNativeModule.NAME,
+                                CodePushNativeModule.class.getName(),
+                                false,
+                                false,
+                                false,
+                                false,
+                                true
+                        )
+                );
+                return reactModuleInfoMap;
+            }
+        };
     }
+
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactApplicationContext) {
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactApplicationContext) {
         return new ArrayList<>();
     }
 }

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,58 +311,52 @@ 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() {
-                        private boolean hasScheduledNextFrame = false;
-                        private DownloadProgress latestDownloadProgress = null;
+                        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) {
+                                        emitDownloadProgressEvent(downloadProgress);
+                                    }
+                                });
 
                         @Override
                         public void call(DownloadProgress downloadProgress) {
-                            if (!notifyProgress) {
+                            if (!notifyProgress || downloadProgress == null) {
                                 return;
                             }
 
                             latestDownloadProgress = downloadProgress;
                             // If the download is completed, synchronously send the last event.
-                            if (latestDownloadProgress.isCompleted()) {
-                                dispatchDownloadProgressEvent();
+                            if (downloadProgress.isCompleted()) {
+                                progressEventDispatcher.dispatch(downloadProgress);
                                 return;
                             }
 
@@ -368,22 +371,16 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                                     ReactChoreographer.getInstance().postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, new Choreographer.FrameCallback() {
                                         @Override
                                         public void doFrame(long frameTimeNanos) {
-                                            if (!latestDownloadProgress.isCompleted()) {
-                                                dispatchDownloadProgressEvent();
+                                            try {
+                                                progressEventDispatcher.dispatch(latestDownloadProgress);
+                                            } finally {
+                                                hasScheduledNextFrame = false;
                                             }
-
-                                            hasScheduledNextFrame = false;
                                         }
                                     });
                                 }
                             });
                         }
-
-                        public void dispatchDownloadProgressEvent() {
-                            getReactApplicationContext()
-                                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                                    .emit(CodePushConstants.DOWNLOAD_PROGRESS_EVENT_NAME, latestDownloadProgress.createWritableMap());
-                        }
                     });
 
                     JSONObject newPackage = mUpdateManager.getPackage(CodePushUtils.tryGetString(updatePackage, CodePushConstants.PACKAGE_HASH_KEY));
@@ -396,12 +393,8 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
                     CodePushUtils.log(e);
                     promise.reject(e);
                 }
-
-                return null;
             }
-        };
-
-        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+        });
     }
 
     @ReactMethod
@@ -426,16 +419,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;
@@ -456,7 +450,7 @@ public class CodePushNativeModule extends ReactContextBaseJavaModule {
 
                         if (previousPackage == null) {
                             promise.resolve(null);
-                            return null;
+                            return;
                         }
 
                         promise.resolve(CodePushUtils.convertJsonObjectToWritable(previousPackage));
@@ -485,19 +479,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);
@@ -509,7 +499,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);
@@ -521,41 +511,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);
@@ -565,13 +554,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.
@@ -625,17 +613,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
@@ -692,7 +676,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/DownloadProgress.java

@@ -27,4 +27,8 @@ class DownloadProgress {
     public boolean isCompleted() {
         return mTotalBytes == mReceivedBytes;
     }
+
+    long getReceivedBytes() {
+        return mReceivedBytes;
+    }
 }

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

@@ -0,0 +1,23 @@
+package com.microsoft.codepush.react;
+
+class DownloadProgressEventDispatcher {
+    interface EventEmitter {
+        void emit(DownloadProgress downloadProgress);
+    }
+
+    private final EventEmitter mEventEmitter;
+    private long mLastDispatchedBytes = -1;
+
+    DownloadProgressEventDispatcher(EventEmitter eventEmitter) {
+        mEventEmitter = eventEmitter;
+    }
+
+    synchronized void dispatch(DownloadProgress downloadProgress) {
+        if (downloadProgress == null || downloadProgress.getReceivedBytes() <= mLastDispatchedBytes) {
+            return;
+        }
+
+        mEventEmitter.emit(downloadProgress);
+        mLastDispatchedBytes = downloadProgress.getReceivedBytes();
+    }
+}