rn-update 1.0.0

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

@@ -0,0 +1,394 @@
+/**
+ * [INPUT]: 依赖 Android Context/Resources、base 与 split APK、SafeZipFile、UpdateFileUtils 以及补丁 copies/copiesCrc 清单
+ * [OUTPUT]: 对内提供 copyFromResource，按精确路径、规范化资源名或 CRC 内容匹配复制未变资源到多个目标
+ * [POS]: Android pdiff 资源物化器，连接安装包内容与 DownloadTask 补丁目录，并在重打包内容漂移时主动失败
+ */
+package cn.reactnative.modules.update;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.util.TypedValue;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.zip.ZipEntry;
+import java.util.regex.Pattern;
+
+final class BundledResourceCopier {
+    private static final Pattern VERSION_QUALIFIER_PATTERN = Pattern.compile("-v\\d+(?=/)");
+    private static final String AAB_BASE_PREFIX = "base/";
+
+    private final Context context;
+
+    private static final class ResolvedResourceSource {
+        final int resourceId;
+        final String assetPath;
+
+        ResolvedResourceSource(int resourceId, String assetPath) {
+            this.resourceId = resourceId;
+            this.assetPath = assetPath;
+        }
+    }
+
+    // Holds the exact archive a CRC32 match came from, so the fallback copy
+    // reads from that archive even if another APK exposes the same entry name
+    // with different bytes.
+    private static final class ZipSource {
+        final ZipEntry entry;
+        final SafeZipFile zipFile;
+
+        ZipSource(ZipEntry entry, SafeZipFile zipFile) {
+            this.entry = entry;
+            this.zipFile = zipFile;
+        }
+    }
+
+    BundledResourceCopier(Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    void copyFromResource(
+        HashMap<String, ArrayList<File>> resToCopy,
+        HashMap<String, Long> crcByFrom
+    ) throws IOException {
+        ArrayList<String> apkPaths = collectApkPaths();
+        HashMap<String, ZipEntry> availableEntries = new HashMap<String, ZipEntry>();
+        HashMap<String, SafeZipFile> zipFileMap = new HashMap<String, SafeZipFile>();
+        HashMap<String, SafeZipFile> entryToZipFileMap = new HashMap<String, SafeZipFile>();
+        // Content checksum index: CRC32 -> matched archive source. Lets us
+        // locate a file by content when its origin path is not present verbatim
+        // on device (e.g. APK baseline diff applied on an AAB/split-apk install
+        // whose res/ paths were shortened). First entry for a given crc wins.
+        HashMap<Long, ZipSource> crcToEntry = new HashMap<Long, ZipSource>();
+
+        try {
+            for (String apkPath : apkPaths) {
+                SafeZipFile zipFile = new SafeZipFile(new File(apkPath));
+                zipFileMap.put(apkPath, zipFile);
+                Enumeration<? extends ZipEntry> entries = zipFile.entries();
+                while (entries.hasMoreElements()) {
+                    ZipEntry ze = entries.nextElement();
+                    String entryName = ze.getName();
+                    if (!availableEntries.containsKey(entryName)) {
+                        availableEntries.put(entryName, ze);
+                        entryToZipFileMap.put(entryName, zipFile);
+                    }
+                    long crc = ze.getCrc();
+                    if (crc != -1L && !crcToEntry.containsKey(crc)) {
+                        crcToEntry.put(crc, new ZipSource(ze, zipFile));
+                    }
+                }
+            }
+
+            HashMap<String, String> normalizedEntryMap = new HashMap<String, String>();
+            for (String entryName : availableEntries.keySet()) {
+                String normalized = normalizeResPath(entryName);
+                normalizedEntryMap.putIfAbsent(normalized, entryName);
+            }
+
+            SafeZipFile baseZipFile = zipFileMap.get(context.getPackageResourcePath());
+            HashMap<String, ArrayList<File>> remainingFiles =
+                new HashMap<String, ArrayList<File>>(resToCopy);
+            // Track copies that were located but failed to write. These are real
+            // failures (disk full, corrupt archive) that must fail the update,
+            // not skips — otherwise the update activates with missing resources.
+            ArrayList<String> failedCopies = new ArrayList<String>();
+            // Entries whose manifest-declared CRC32 could not be satisfied by
+            // any installed archive: the path-matched file has different bytes
+            // and no entry anywhere carries the expected content. Copying would
+            // install a wrong resource (rebuilt binary with drifted assets), so
+            // these fail the whole patch — the JS strategy chain then falls
+            // back to the full package.
+            ArrayList<String> crcMismatches = new ArrayList<String>();
+
+            for (String fromPath : new ArrayList<String>(remainingFiles.keySet())) {
+                ArrayList<File> targets = remainingFiles.get(fromPath);
+                if (targets == null || targets.isEmpty()) {
+                    continue;
+                }
+
+                ZipEntry entry = availableEntries.get(fromPath);
+                String actualSourcePath = fromPath;
+                SafeZipFile matchedZipFile = null;
+                ResolvedResourceSource resolvedResource = null;
+                Long wantedCrc = crcByFrom != null ? crcByFrom.get(fromPath) : null;
+
+                if (entry == null) {
+                    String normalizedFrom = normalizeResPath(fromPath);
+                    String actualEntry = normalizedEntryMap.get(normalizedFrom);
+                    if (actualEntry != null) {
+                        entry = availableEntries.get(actualEntry);
+                        actualSourcePath = actualEntry;
+                    }
+                }
+
+                // Verify a path-matched entry against the manifest-declared
+                // CRC32: a rebuilt binary can keep the path but drift the
+                // content. On mismatch, discard the path match and try to
+                // locate the expected content elsewhere. An entry with an
+                // unknown CRC (-1) cannot be verified and is accepted as-is.
+                if (entry != null && wantedCrc != null
+                    && entry.getCrc() != -1L && entry.getCrc() != wantedCrc.longValue()) {
+                    entry = null;
+                    actualSourcePath = fromPath;
+                }
+
+                // Content (CRC32) match: robust across APK/AAB packaging because
+                // the checksum is over the uncompressed file content, not its
+                // path. Preferred over the resource-id heuristic below.
+                if (entry == null && wantedCrc != null) {
+                    ZipSource matched = crcToEntry.get(wantedCrc);
+                    if (matched != null) {
+                        entry = matched.entry;
+                        matchedZipFile = matched.zipFile;
+                        actualSourcePath = matched.entry.getName();
+                    }
+                }
+
+                // A declared CRC that no installed entry satisfies is a hard
+                // content mismatch. The resource-id heuristic below cannot be
+                // trusted here: the content index above already covers every
+                // entry, so anything the heuristic finds has the wrong bytes.
+                if (entry == null && wantedCrc != null) {
+                    crcMismatches.add(fromPath);
+                    remainingFiles.remove(fromPath);
+                    continue;
+                }
+
+                if (entry == null) {
+                    resolvedResource = resolveBundledResource(fromPath);
+                    if (resolvedResource != null) {
+                        actualSourcePath = resolvedResource.assetPath;
+                        // resolveBundledResource resolved the density-correct
+                        // file path; copy that exact entry from the already-open
+                        // archives so the right variant is used. (openRawResource
+                        // would re-resolve the id at the current configuration
+                        // density and ignore the requested one.)
+                        ZipEntry resolvedEntry = availableEntries.get(actualSourcePath);
+                        if (resolvedEntry != null) {
+                            entry = resolvedEntry;
+                            resolvedResource = null;
+                        }
+                    }
+                }
+
+                if (entry == null && resolvedResource == null) {
+                    continue;
+                }
+
+                File lastTarget = null;
+                for (File target : targets) {
+                    try {
+                        if (lastTarget != null) {
+                            UpdateFileUtils.copyFile(lastTarget, target);
+                        } else if (entry != null) {
+                            SafeZipFile sourceZipFile = matchedZipFile != null
+                                ? matchedZipFile
+                                : entryToZipFileMap.get(actualSourcePath);
+                            if (sourceZipFile == null) {
+                                sourceZipFile = baseZipFile;
+                            }
+                            sourceZipFile.unzipToFile(entry, target);
+                        } else {
+                            InputStream in = openResolvedResourceStream(resolvedResource);
+                            UpdateFileUtils.copyInputStreamToFile(in, target);
+                        }
+                        lastTarget = target;
+                    } catch (IOException e) {
+                        // A located resource that fails to write is a hard
+                        // failure, not a skip: record it and fail the update
+                        // after the loop so a broken update is not activated.
+                        Log.e(
+                            UpdateContext.TAG,
+                            "Failed to copy resource "
+                                + actualSourcePath
+                                + " to "
+                                + target,
+                            e
+                        );
+                        failedCopies.add(actualSourcePath + " -> " + target);
+                    }
+                }
+                remainingFiles.remove(fromPath);
+            }
+
+            if (!crcMismatches.isEmpty()) {
+                throw new IOException(
+                    "Bundled resource content mismatch (crc32) for "
+                        + crcMismatches.size() + " entries: " + crcMismatches
+                );
+            }
+
+            if (!failedCopies.isEmpty()) {
+                throw new IOException(
+                    "Failed to copy " + failedCopies.size()
+                        + " bundled resource(s): " + failedCopies
+                );
+            }
+
+            if (!remainingFiles.isEmpty()) {
+                Log.w(
+                    UpdateContext.TAG,
+                    "Skipped " + remainingFiles.size() + " missing bundled resources"
+                );
+            }
+        } finally {
+            closeZipFiles(zipFileMap);
+        }
+    }
+
+    private String normalizeResPath(String path) {
+        String result = path;
+        if (result.startsWith(AAB_BASE_PREFIX)) {
+            result = result.substring(AAB_BASE_PREFIX.length());
+        }
+        return VERSION_QUALIFIER_PATTERN.matcher(result).replaceAll("");
+    }
+
+    private String extractResourceType(String directoryName) {
+        int qualifierIndex = directoryName.indexOf('-');
+        if (qualifierIndex == -1) {
+            return directoryName;
+        }
+        return directoryName.substring(0, qualifierIndex);
+    }
+
+    private String extractResourceName(String fileName) {
+        if (fileName.endsWith(".9.png")) {
+            return fileName.substring(0, fileName.length() - ".9.png".length());
+        }
+        int extensionIndex = fileName.lastIndexOf('.');
+        if (extensionIndex == -1) {
+            return fileName;
+        }
+        return fileName.substring(0, extensionIndex);
+    }
+
+    private Integer parseDensityQualifier(String directoryName) {
+        String[] qualifiers = directoryName.split("-");
+        for (String qualifier : qualifiers) {
+            if ("ldpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_LOW;
+            }
+            if ("mdpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_MEDIUM;
+            }
+            if ("hdpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_HIGH;
+            }
+            if ("xhdpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_XHIGH;
+            }
+            if ("xxhdpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_XXHIGH;
+            }
+            if ("xxxhdpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_XXXHIGH;
+            }
+            if ("tvdpi".equals(qualifier)) {
+                return DisplayMetrics.DENSITY_TV;
+            }
+        }
+        return null;
+    }
+
+    private ResolvedResourceSource resolveBundledResource(String resourcePath) {
+        String normalizedPath = normalizeResPath(resourcePath);
+        if (normalizedPath.startsWith("res/")) {
+            normalizedPath = normalizedPath.substring("res/".length());
+        }
+
+        int slash = normalizedPath.indexOf('/');
+        if (slash == -1 || slash == normalizedPath.length() - 1) {
+            return null;
+        }
+
+        String directoryName = normalizedPath.substring(0, slash);
+        String fileName = normalizedPath.substring(slash + 1);
+        String resourceType = extractResourceType(directoryName);
+        String resourceName = extractResourceName(fileName);
+        if (resourceType == null || resourceType.isEmpty() || resourceName.isEmpty()) {
+            return null;
+        }
+
+        Resources resources = context.getResources();
+        int resourceId = resources.getIdentifier(resourceName, resourceType, context.getPackageName());
+        if (resourceId == 0) {
+            return null;
+        }
+
+        TypedValue typedValue = new TypedValue();
+        try {
+            Integer density = parseDensityQualifier(directoryName);
+            if (density != null) {
+                resources.getValueForDensity(resourceId, density, typedValue, true);
+            } else {
+                resources.getValue(resourceId, typedValue, true);
+            }
+        } catch (Resources.NotFoundException e) {
+            return null;
+        }
+
+        if (typedValue.string == null) {
+            return null;
+        }
+
+        String assetPath = typedValue.string.toString();
+        if (assetPath.startsWith("/")) {
+            assetPath = assetPath.substring(1);
+        }
+
+        return new ResolvedResourceSource(resourceId, assetPath);
+    }
+
+    private InputStream openResolvedResourceStream(ResolvedResourceSource source) throws IOException {
+        // Defensive fallback only: reached when the density-resolved assetPath
+        // is not present as a zip entry in any loaded APK. Best-effort, resolves
+        // at the current configuration density.
+        try {
+            return context.getResources().openRawResource(source.resourceId);
+        } catch (Resources.NotFoundException e) {
+            throw new IOException("Unable to open resolved resource: " + source.assetPath, e);
+        }
+    }
+
+    private ArrayList<String> collectApkPaths() {
+        ArrayList<String> apkPaths = new ArrayList<String>();
+        apkPaths.add(context.getPackageResourcePath());
+
+        try {
+            ApplicationInfo appInfo =
+                context.getPackageManager().getApplicationInfo(context.getPackageName(), 0);
+            if (appInfo.splitSourceDirs != null) {
+                for (String splitPath : appInfo.splitSourceDirs) {
+                    apkPaths.add(splitPath);
+                }
+            }
+        } catch (PackageManager.NameNotFoundException e) {
+            if (UpdateContext.DEBUG) {
+                Log.w(UpdateContext.TAG, "Failed to get application info: " + e.getMessage());
+            }
+        }
+
+        return apkPaths;
+    }
+
+    private void closeZipFiles(HashMap<String, SafeZipFile> zipFileMap) {
+        for (SafeZipFile zipFile : zipFileMap.values()) {
+            try {
+                zipFile.close();
+            } catch (IOException e) {
+                if (UpdateContext.DEBUG) {
+                    Log.w(UpdateContext.TAG, "Failed to close zip file", e);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * [INPUT]: 无依赖（自包含纯函数），为 cleanup JNI 的 keepnames 契约服务
+ * [OUTPUT]: 提供 select，从 current/previous/running 中选出最多两个去重版本名（超限返回 null）
+ * [POS]: Android 清理流程的 JNI keepnames 选择器，与 cpp 清理逻辑的版本名约束对齐
+ */
+package cn.reactnative.modules.update;
+
+/** Selects the at-most-two distinct version names supported by cleanup JNI. */
+final class CleanupKeepNames {
+    private CleanupKeepNames() {
+    }
+
+    static String[] select(String current, String previous, String running) {
+        String[] keep = new String[2];
+        for (String candidate : new String[] {current, previous, running}) {
+            if (candidate == null || candidate.isEmpty()
+                || candidate.equals(keep[0]) || candidate.equals(keep[1])) {
+                continue;
+            }
+            if (keep[0] == null) {
+                keep[0] = candidate;
+            } else if (keep[1] == null) {
+                keep[1] = candidate;
+            } else {
+                return null;
+            }
+        }
+        return keep;
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * [INPUT]: 依赖 cpp/patch_core 对补丁 copies 清单的分组结果
+ * [OUTPUT]: 对内提供 from 与 toPaths 的 JNI 复制分组载体
+ * [POS]: Android Java/C++ 边界的复制 DTO，由 DownloadTask 转换为真实目标文件
+ */
+package cn.reactnative.modules.update;
+
+class CopyGroupResult {
+    String from;
+    String[] toPaths;
+}

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

@@ -0,0 +1,120 @@
+/**
+ * [INPUT]: 依赖默认 UncaughtExceptionHandler、进程/主线程时钟与 NativeCheckOrchestrator 的单轮救援能力
+ * [OUTPUT]: 对内提供幂等 install，在启动早期崩溃窗口内按主/后台线程预算等待原生修复检查
+ * [POS]: Android 冷启动救砖保险丝，只延迟进程死亡且始终把控制权交还既有崩溃处理链
+ */
+package cn.reactnative.modules.update;
+
+import android.os.Looper;
+import android.os.Process;
+import android.os.SystemClock;
+import android.util.Log;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Crash-moment brick rescue (NATIVE_CHECKUPDATE_DESIGN §11): when the app is
+ * dying of an uncaught exception during startup, the process is still alive
+ * and JS will never run again — a natural, false-positive-free window to
+ * finish the cold-start update check before the crash dialog appears.
+ *
+ * Etiquette: the previous default handler (crash reporters chain the same
+ * way) is always invoked afterwards, whether the rescue ran, timed out or
+ * threw. The rescue itself runs on a worker thread and the handler only
+ * waits with a hard timeout, so even a deadlocked rescue (a thread that died
+ * holding a lock) can only delay the process death, never prevent it.
+ */
+final class CrashRescue {
+    private static final AtomicBoolean installed = new AtomicBoolean(false);
+    private static final AtomicBoolean rescueAttempted = new AtomicBoolean(false);
+    // ≈ process start: install() runs during the first bundle resolution.
+    // Deliberately not Process.getStartElapsedRealtime(), which is API 24+
+    // while the module's minSdk floor is lower — a NoSuchMethodError here
+    // would silently disable the whole rescue on those devices.
+    private static volatile long installedAtElapsedRealtime;
+    private static final long TRIGGER_UPTIME_MILLIS = 60000;
+    private static final long BUDGET_BACKGROUND_THREAD_MILLIS = 10000;
+    // A held main thread stops input dispatch; stay under the ~5s ANR window.
+    private static final long BUDGET_MAIN_THREAD_MILLIS = 3500;
+
+    private CrashRescue() {
+    }
+
+    static void install() {
+        if (!installed.compareAndSet(false, true)) {
+            return;
+        }
+        installedAtElapsedRealtime = SystemClock.elapsedRealtime();
+        final Thread.UncaughtExceptionHandler previous =
+            Thread.getDefaultUncaughtExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread thread, Throwable error) {
+                try {
+                    maybeHoldForRescue(thread);
+                } catch (Throwable ignored) {
+                    // The dying process owes the previous handler its turn no
+                    // matter what the rescue did.
+                }
+                if (previous != null) {
+                    previous.uncaughtException(thread, error);
+                } else {
+                    // Mirror RuntimeInit's default behaviour so the process
+                    // still dies when no other handler was registered.
+                    Process.killProcess(Process.myPid());
+                    System.exit(10);
+                }
+            }
+        });
+    }
+
+    private static void maybeHoldForRescue(Thread crashedThread) {
+        // Once per process; a second crashing thread passes straight through
+        // instead of waiting behind the first (§11.3: prefer under-rescuing
+        // over wedging the teardown).
+        if (!rescueAttempted.compareAndSet(false, true)) {
+            return;
+        }
+        long uptimeMillis =
+            SystemClock.elapsedRealtime() - installedAtElapsedRealtime;
+        boolean roundInFlight = NativeCheckOrchestrator.isRoundInFlight();
+        // Early crashes are the brick signature; a crash with an in-flight
+        // round is worth finishing regardless of uptime. Everything else is
+        // an ordinary crash whose UX must not be delayed.
+        if (uptimeMillis >= TRIGGER_UPTIME_MILLIS && !roundInFlight) {
+            return;
+        }
+        boolean onMainThread = crashedThread == Looper.getMainLooper().getThread();
+        long budgetMillis = onMainThread
+            ? BUDGET_MAIN_THREAD_MILLIS
+            : BUDGET_BACKGROUND_THREAD_MILLIS;
+        final long deadlineNanos =
+            System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(budgetMillis);
+        Log.i(UpdateContext.TAG, "crash rescue: holding process for up to "
+            + budgetMillis + "ms (uptime " + uptimeMillis + "ms)");
+
+        final CountDownLatch done = new CountDownLatch(1);
+        Thread worker = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    NativeCheckOrchestrator.runRescue(deadlineNanos);
+                } catch (Throwable e) {
+                    Log.w(UpdateContext.TAG, "crash rescue failed: " + e);
+                } finally {
+                    done.countDown();
+                }
+            }
+        }, "pakta-crash-rescue");
+        worker.setDaemon(true);
+        worker.start();
+        try {
+            if (!done.await(budgetMillis, TimeUnit.MILLISECONDS)) {
+                Log.w(UpdateContext.TAG, "crash rescue: budget exhausted, letting go");
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}