react-native-update 10.39.0 → 10.40.0-beta.0

package/android/src/main/java/cn/reactnative/modules/update/NativeUpdateCore.java

@@ -11,19 +11,11 @@ final class NativeUpdateCore {
             return;
         }
 
-        try {
-            System.loadLibrary("c++_shared");
-        } catch (UnsatisfiedLinkError ignored) {
-            // Fall back to the transitive dependency load path when the host app already
-            // packages libc++_shared.so but the linker has not loaded it yet.
-        }
-
         try {
             System.loadLibrary("rnupdate");
         } catch (UnsatisfiedLinkError error) {
             UnsatisfiedLinkError wrapped = new UnsatisfiedLinkError(
-                "Failed to load rnupdate. Ensure the host app packages libc++_shared.so "
-                    + "when using the shared C++ runtime. Original error: "
+                "Failed to load rnupdate native library. Original error: "
                     + error.getMessage());
             wrapped.initCause(error);
             throw wrapped;

package/android/src/main/java/cn/reactnative/modules/update/ReactReloadManager.java

@@ -0,0 +1,220 @@
+package cn.reactnative.modules.update;
+
+import android.app.Activity;
+import android.content.Context;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.react.ReactActivity;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactDelegate;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.bridge.JSBundleLoader;
+import com.facebook.react.bridge.ReactApplicationContext;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+final class ReactReloadManager {
+    private ReactReloadManager() {
+    }
+
+    static void restartApp(
+        UpdateContext updateContext,
+        ReactApplicationContext reactContext,
+        @Nullable String hash
+    ) throws Throwable {
+        if (hash != null) {
+            updateContext.switchVersion(hash);
+        }
+
+        Context application = reactContext.getApplicationContext();
+        Activity currentActivity = reactContext.getCurrentActivity();
+        String updateBundlePath = updateContext.getBundleUrl();
+
+        Object reactHost = getReactHost(currentActivity, application);
+        if (reactHost != null) {
+            try {
+                reloadReactHost(reactHost, createBundleLoader(application, updateBundlePath, true));
+                return;
+            } catch (Throwable err) {
+                Log.e(UpdateContext.TAG, "Failed to reload via ReactHost", err);
+            }
+        }
+
+        JSBundleLoader loader = createBundleLoader(application, updateBundlePath, false);
+        try {
+            ReactInstanceManager instanceManager =
+                resolveReactInstanceManager(updateContext, application);
+
+            try {
+                Field loadField = instanceManager.getClass().getDeclaredField("mBundleLoader");
+                loadField.setAccessible(true);
+                loadField.set(instanceManager, loader);
+            } catch (Throwable err) {
+                Field jsBundleField = instanceManager.getClass().getDeclaredField("mJSBundleFile");
+                jsBundleField.setAccessible(true);
+                jsBundleField.set(instanceManager, updateContext.getBundleUrl());
+            }
+
+            instanceManager.recreateReactContextInBackground();
+        } catch (Throwable err) {
+            if (currentActivity == null) {
+                throw err;
+            }
+
+            try {
+                Object currentReactHost = getReactHost(currentActivity, application);
+                if (currentReactHost == null) {
+                    throw err;
+                }
+                reloadReactHost(
+                    currentReactHost,
+                    createBundleLoader(application, updateBundlePath, true)
+                );
+            } catch (Throwable ignored) {
+                currentActivity.recreate();
+            }
+        }
+    }
+
+    private static Field getCompatibleField(Class<?> clazz, String fieldName)
+        throws NoSuchFieldException {
+        try {
+            return clazz.getDeclaredField("m" + capitalize(fieldName));
+        } catch (NoSuchFieldException e) {
+            try {
+                return clazz.getDeclaredField(fieldName);
+            } catch (NoSuchFieldException e2) {
+                throw new NoSuchFieldException(
+                    "Field not found with either name: m"
+                        + capitalize(fieldName)
+                        + " or "
+                        + fieldName
+                );
+            }
+        }
+    }
+
+    private static String capitalize(String str) {
+        if (str == null || str.length() == 0) {
+            return str;
+        }
+        return str.substring(0, 1).toUpperCase() + str.substring(1);
+    }
+
+    private static String getDefaultBundleAssetName(Context application) {
+        String bundleAssetName = "index.android.bundle";
+        if (!(application instanceof ReactApplication)) {
+            return bundleAssetName;
+        }
+
+        try {
+            ReactNativeHost reactNativeHost = ((ReactApplication) application).getReactNativeHost();
+            if (reactNativeHost == null) {
+                return bundleAssetName;
+            }
+
+            Method getBundleAssetNameMethod = ReactNativeHost.class.getDeclaredMethod("getBundleAssetName");
+            getBundleAssetNameMethod.setAccessible(true);
+            Object resolvedBundleAssetName = getBundleAssetNameMethod.invoke(reactNativeHost);
+            if (resolvedBundleAssetName instanceof String && !((String) resolvedBundleAssetName).isEmpty()) {
+                return (String) resolvedBundleAssetName;
+            }
+        } catch (Exception e) {
+            Log.e(UpdateContext.TAG, "Failed to get default asset name from ReactNativeHost", e);
+        }
+
+        return bundleAssetName;
+    }
+
+    private static String toAssetUrl(String bundleAssetName) {
+        if (bundleAssetName == null || bundleAssetName.isEmpty()) {
+            return "assets://index.android.bundle";
+        }
+        if (bundleAssetName.startsWith("assets://")) {
+            return bundleAssetName;
+        }
+        return "assets://" + bundleAssetName;
+    }
+
+    private static JSBundleLoader createBundleLoader(
+        Context application,
+        @Nullable String updateBundlePath,
+        boolean loadAssetSynchronously
+    ) {
+        if (updateBundlePath != null) {
+            return JSBundleLoader.createFileLoader(updateBundlePath);
+        }
+        return JSBundleLoader.createAssetLoader(
+            application,
+            toAssetUrl(getDefaultBundleAssetName(application)),
+            loadAssetSynchronously
+        );
+    }
+
+    @Nullable
+    private static Object getReactHost(@Nullable Activity currentActivity, Context application) {
+        if (currentActivity instanceof ReactActivity) {
+            try {
+                Method getReactDelegateMethod = ReactActivity.class.getMethod("getReactDelegate");
+                ReactDelegate reactDelegate =
+                    (ReactDelegate) getReactDelegateMethod.invoke(currentActivity);
+                if (reactDelegate != null) {
+                    Field reactHostField = getCompatibleField(reactDelegate.getClass(), "reactHost");
+                    reactHostField.setAccessible(true);
+                    Object reactHost = reactHostField.get(reactDelegate);
+                    if (reactHost != null) {
+                        return reactHost;
+                    }
+                }
+            } catch (Throwable ignored) {
+            }
+        }
+
+        try {
+            Method getReactHostMethod = application.getClass().getMethod("getReactHost");
+            return getReactHostMethod.invoke(application);
+        } catch (Throwable ignored) {
+        }
+
+        return null;
+    }
+
+    private static void reloadReactHost(Object reactHost, JSBundleLoader loader) throws Throwable {
+        try {
+            Field devSupportField = getCompatibleField(reactHost.getClass(), "useDevSupport");
+            devSupportField.setAccessible(true);
+            devSupportField.set(reactHost, false);
+        } catch (Throwable ignored) {
+        }
+
+        Field reactHostDelegateField = getCompatibleField(reactHost.getClass(), "reactHostDelegate");
+        reactHostDelegateField.setAccessible(true);
+        Object reactHostDelegate = reactHostDelegateField.get(reactHost);
+
+        String bundleFieldName = "jsBundleLoader";
+        if ("expo.modules.ExpoReactHostFactory.ExpoReactHostDelegate".equals(
+            reactHostDelegate.getClass().getCanonicalName()
+        )) {
+            bundleFieldName = "_jsBundleLoader";
+        }
+
+        Field jsBundleLoaderField = reactHostDelegate.getClass().getDeclaredField(bundleFieldName);
+        jsBundleLoaderField.setAccessible(true);
+        jsBundleLoaderField.set(reactHostDelegate, loader);
+
+        Method reloadMethod = reactHost.getClass().getMethod("reload", String.class);
+        reloadMethod.invoke(reactHost, "react-native-update");
+    }
+
+    private static ReactInstanceManager resolveReactInstanceManager(
+        UpdateContext updateContext,
+        Context application
+    ) {
+        ReactInstanceManager instanceManager = updateContext.getCustomReactInstanceManager();
+        if (instanceManager != null) {
+            return instanceManager;
+        }
+        return ((ReactApplication) application).getReactNativeHost().getReactInstanceManager();
+    }
+}

package/android/src/main/java/cn/reactnative/modules/update/SafeZipFile.java

@@ -66,8 +66,9 @@ public class SafeZipFile extends ZipFile {
             throw new SecurityException("Illegal name: " + name);
         }
 
-        
-        Log.d("react-native-update", "Unzipping " + name);
+        if (UpdateContext.DEBUG) {
+            Log.d(UpdateContext.TAG, "Unzipping " + name);
+        }
 
         if (ze.isDirectory()) {
             target.mkdirs();
@@ -77,6 +78,11 @@ public class SafeZipFile extends ZipFile {
     }
 
     public void unzipToFile(ZipEntry ze, File target) throws IOException {
+        File parent = target.getParentFile();
+        if (parent != null && !parent.exists() && !parent.mkdirs() && !parent.exists()) {
+            throw new IOException("Failed to create parent dir for " + target);
+        }
+
         try (InputStream inputStream = getInputStream(ze)) {
             try (BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream(target));
                  BufferedInputStream input = new BufferedInputStream(inputStream)) {
@@ -89,4 +95,4 @@ public class SafeZipFile extends ZipFile {
         }
     }
 
-}
+}

package/android/src/main/java/cn/reactnative/modules/update/UiThreadRunner.java

@@ -0,0 +1,36 @@
+package cn.reactnative.modules.update;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.UiThreadUtil;
+
+final class UiThreadRunner {
+    interface Operation {
+        void run() throws Throwable;
+    }
+
+    private UiThreadRunner() {
+    }
+
+    static void run(
+        @Nullable final Promise promise,
+        final String operationName,
+        final Operation operation
+    ) {
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    operation.run();
+                } catch (Throwable error) {
+                    if (promise != null) {
+                        promise.reject(operationName + " failed", error);
+                    } else {
+                        Log.e(UpdateContext.TAG, operationName + " failed", error);
+                    }
+                }
+            }
+        });
+    }
+}

package/android/src/main/java/cn/reactnative/modules/update/UpdateContext.java

@@ -8,25 +8,26 @@ import android.os.Build;
 import android.os.Environment;
 import android.util.Log;
 import com.facebook.react.ReactInstanceManager;
-import java.util.HashMap;
-import java.util.Map;
+import java.io.File;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
-import java.io.File;
 
 public class UpdateContext {
     static {
         NativeUpdateCore.ensureLoaded();
     }
 
-    private Context context;
-    private File rootDir;
-    private Executor executor;
+    static final String TAG = "react-native-update";
+    static final boolean DEBUG = BuildConfig.DEBUG;
 
-    public static boolean DEBUG = true;
-    private static ReactInstanceManager mReactInstanceManager;
-    private static boolean isUsingBundleUrl = false;
-    private static boolean ignoreRollback = false;
+    private final Context context;
+    private final File rootDir;
+    private final Executor executor;
+    private final SharedPreferences sp;
+
+    private ReactInstanceManager reactInstanceManager;
+    private boolean isUsingBundleUrl;
+    private boolean ignoreRollback;
     private static final int STATE_OP_SWITCH_VERSION = 1;
     private static final int STATE_OP_MARK_SUCCESS = 2;
     private static final int STATE_OP_ROLLBACK = 3;
@@ -38,6 +39,7 @@ public class UpdateContext {
     // Singleton instance
     private static UpdateContext sInstance;
     private static final Object sLock = new Object();
+    private static ReactInstanceManager pendingReactInstanceManager;
 
     private static native StateCoreResult syncStateWithBinaryVersion(
         String packageVersion,
@@ -54,16 +56,17 @@ public class UpdateContext {
     );
 
     public UpdateContext(Context context) {
-        this.context = context;
+        this.context = context.getApplicationContext();
         this.executor = Executors.newSingleThreadExecutor();
 
-        this.rootDir = new File(context.getFilesDir(), "_update");
+        this.rootDir = new File(this.context.getFilesDir(), "_update");
 
-        if (!rootDir.exists()) {
-            rootDir.mkdir();
+        if (!rootDir.exists() && !rootDir.mkdirs() && !rootDir.exists()) {
+            throw new IllegalStateException("Failed to create update root dir: " + rootDir);
         }
 
-        this.sp = context.getSharedPreferences("update", Context.MODE_PRIVATE);
+        this.sp = this.context.getSharedPreferences("update", Context.MODE_PRIVATE);
+        this.reactInstanceManager = pendingReactInstanceManager;
 
         String packageVersion = getPackageVersion();
         String buildTime = getBuildTime();
@@ -107,6 +110,10 @@ public class UpdateContext {
         return isUsingBundleUrl;
     }
 
+    private void enqueue(DownloadTaskParams params) {
+        executor.execute(new DownloadTask(context, params));
+    }
+
     public interface DownloadFileListener {
         void onDownloadCompleted(DownloadTaskParams params);
         void onDownloadFailed(Throwable error);
@@ -120,7 +127,7 @@ public class UpdateContext {
         params.listener = listener;
         params.targetFile = new File(rootDir, hash + ".ppk");
         params.unzipDirectory = new File(rootDir, hash);
-        new DownloadTask(context).executeOnExecutor(this.executor, params);
+        enqueue(params);
     }
 
     public void downloadFile(String url, String hash, String fileName, DownloadFileListener listener) {
@@ -138,7 +145,7 @@ public class UpdateContext {
 
         }
 //        params.unzipDirectory = new File(rootDir, hash);
-        new DownloadTask(context).executeOnExecutor(this.executor, params);
+        enqueue(params);
     }
 
     public void downloadPatchFromApk(String url, String hash, DownloadFileListener listener) {
@@ -149,7 +156,7 @@ public class UpdateContext {
         params.listener = listener;
         params.targetFile = new File(rootDir, hash + ".apk.patch");
         params.unzipDirectory = new File(rootDir, hash);
-        new DownloadTask(context).executeOnExecutor(this.executor, params);
+        enqueue(params);
     }
 
     public void downloadPatchFromPpk(String url, String hash, String originHash, DownloadFileListener listener) {
@@ -162,11 +169,9 @@ public class UpdateContext {
         params.targetFile = new File(rootDir, originHash + "-" + hash + ".ppk.patch");
         params.unzipDirectory = new File(rootDir, hash);
         params.originDirectory = new File(rootDir, originHash);
-        new DownloadTask(context).executeOnExecutor(this.executor, params);
+        enqueue(params);
     }
 
-    private SharedPreferences sp;
-
     private StateCoreResult getStateSnapshot() {
         StateCoreResult state = new StateCoreResult();
         state.packageVersion = sp.getString("packageVersion", null);
@@ -203,7 +208,7 @@ public class UpdateContext {
 
     private void persistEditor(SharedPreferences.Editor editor, String reason) {
         if (!editor.commit() && DEBUG) {
-            Log.w("react-native-update", "Failed to persist update state for " + reason);
+            Log.w(TAG, "Failed to persist update state for " + reason);
         }
     }
 
@@ -314,11 +319,16 @@ public class UpdateContext {
 
 
     public static void setCustomInstanceManager(ReactInstanceManager instanceManager) {
-        mReactInstanceManager = instanceManager;
+        synchronized (sLock) {
+            pendingReactInstanceManager = instanceManager;
+            if (sInstance != null) {
+                sInstance.reactInstanceManager = instanceManager;
+            }
+        }
     }
 
     public ReactInstanceManager getCustomReactInstanceManager() {
-        return mReactInstanceManager;
+        return reactInstanceManager;
     }
 
     /**
@@ -378,7 +388,7 @@ public class UpdateContext {
         while (currentVersion != null) {
             File bundleFile = new File(rootDir, currentVersion+"/index.bundlejs");
             if (!bundleFile.exists()) {
-                Log.e("getBundleUrl", "Bundle version " + currentVersion + " not found.");
+                Log.e(TAG, "Bundle version " + currentVersion + " not found.");
                 currentVersion = this.rollBack();
                 continue;
             }
@@ -409,6 +419,6 @@ public class UpdateContext {
         params.hash = sp.getString("currentVersion", null);
         params.originHash = sp.getString("lastVersion", null);
         params.unzipDirectory = rootDir;
-        new DownloadTask(context).executeOnExecutor(this.executor, params);
+        enqueue(params);
     }
 }

package/android/src/main/java/cn/reactnative/modules/update/UpdateEventEmitter.java

@@ -0,0 +1,39 @@
+package cn.reactnative.modules.update;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.bridge.WritableMap;
+import java.lang.ref.WeakReference;
+
+final class UpdateEventEmitter {
+    private static WeakReference<ReactApplicationContext> reactContextRef =
+        new WeakReference<ReactApplicationContext>(null);
+
+    private UpdateEventEmitter() {
+    }
+
+    static synchronized void register(ReactApplicationContext reactContext) {
+        reactContextRef = new WeakReference<ReactApplicationContext>(reactContext);
+    }
+
+    @Nullable
+    private static synchronized ReactApplicationContext getReactContext() {
+        return reactContextRef.get();
+    }
+
+    static void sendEvent(String eventName, WritableMap params) {
+        ReactApplicationContext reactContext = getReactContext();
+        if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+            if (UpdateContext.DEBUG) {
+                Log.d(UpdateContext.TAG, "Skipping event " + eventName + " because React context is unavailable");
+            }
+            return;
+        }
+
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit(eventName, params);
+    }
+}

package/android/src/main/java/cn/reactnative/modules/update/UpdateFileUtils.java

@@ -0,0 +1,74 @@
+package cn.reactnative.modules.update;
+
+import android.util.Log;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+final class UpdateFileUtils {
+    private static final int BUFFER_SIZE = 8192;
+
+    private UpdateFileUtils() {
+    }
+
+    static void ensureDirectory(File directory) throws IOException {
+        if (!directory.exists() && !directory.mkdirs() && !directory.exists()) {
+            throw new IOException("Failed to create directory: " + directory);
+        }
+    }
+
+    static void ensureParentDirectory(File file) throws IOException {
+        File parent = file.getParentFile();
+        if (parent != null) {
+            ensureDirectory(parent);
+        }
+    }
+
+    static void removeDirectory(File file) throws IOException {
+        if (UpdateContext.DEBUG) {
+            Log.d(UpdateContext.TAG, "Removing " + file);
+        }
+        if (file.isDirectory()) {
+            File[] files = file.listFiles();
+            if (files != null) {
+                for (File child : files) {
+                    String name = child.getName();
+                    if (name.equals(".") || name.equals("..")) {
+                        continue;
+                    }
+                    removeDirectory(child);
+                }
+            }
+        }
+        if (file.exists() && !file.delete()) {
+            throw new IOException("Failed to delete " + file);
+        }
+    }
+
+    static void copyFile(File from, File to) throws IOException {
+        ensureParentDirectory(to);
+        try (
+            InputStream in = new FileInputStream(from);
+            FileOutputStream out = new FileOutputStream(to)
+        ) {
+            copy(in, out);
+        }
+    }
+
+    static void copyInputStreamToFile(InputStream input, File destination) throws IOException {
+        ensureParentDirectory(destination);
+        try (InputStream in = input; FileOutputStream out = new FileOutputStream(destination)) {
+            copy(in, out);
+        }
+    }
+
+    private static void copy(InputStream in, FileOutputStream out) throws IOException {
+        byte[] buffer = new byte[BUFFER_SIZE];
+        int count;
+        while ((count = in.read(buffer)) != -1) {
+            out.write(buffer, 0, count);
+        }
+    }
+}