fix(android): content-based (CRC32) resource matching for AAB installs + openRawResource density fix (#577)

* fix(android): match copied resources by content (CRC32) for AAB installs

A from-package (PATCH_FROM_APK) hot update copies unchanged resources out
of the on-device package using the path recorded in __diff.json `copies`.
When the baseline uploaded to the server was an APK but the app is
installed from an AAB (Play split APKs), res/ drawable paths are shortened
on device, so the recorded path (e.g. res/drawable-xhdpi-v4/x.webp) does
not exist verbatim and images (webp) silently fall through and go missing.

Add a CRC32 content-match tier in BundledResourceCopier: build a
crc32 -> entry index while scanning the base + split APKs, and when a
`from` path is not found by exact/normalized path, locate the file by the
content checksum supplied via the new manifest `copiesCrc` map. CRC32 is
over the uncompressed content, so it is stable across APK/AAB packaging.
This tier runs before resolveBundledResource (content match is more
reliable than the resource-id heuristic).

Also fix openResolvedResourceStream: use openRawResource(id, typedValue)
with the density-resolved TypedValue instead of openRawResource(id), which
ignored the requested density and could copy the wrong variant.

Backward/forward compatible: manifests without `copiesCrc` (older CLI)
simply skip the CRC tier and fall back to today's path-based behavior.

Requires CLI support: reactnativecn/react-native-update-cli#54

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(android): address review — exact CRC archive + real density-correct copy

Two follow-ups from review on the resource copier:

1. CRC index stored only the entry name, so resolving it back through
   availableEntries could yield a different-content entry when two APKs
   (base + split) expose the same name with different bytes. Store the
   matched ZipEntry together with its SafeZipFile (ZipSource) and copy from
   that archive directly.

2. openRawResource(id, typedValue) is a no-op for density: AOSP's
   ResourcesImpl re-runs getValue(id, value, true) and overwrites the passed
   TypedValue at the current configuration before opening the stream. Instead
   of going through openRawResource (or the hidden openNonAsset API), take the
   density-correct file path resolved by getValueForDensity and copy that
   exact entry from the already-open archives — public API, correct variant.
   openRawResource(id) remains only as a defensive fallback.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: sunnylqm

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

@@ -33,15 +33,36 @@ private static final class ResolvedResourceSource {
         }
     }
 
+    // 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) throws IOException {
+    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) {
@@ -55,6 +76,10 @@ void copyFromResource(HashMap<String, ArrayList<File>> resToCopy) throws IOExcep
                         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));
+                    }
                 }
             }
 
@@ -76,6 +101,7 @@ void copyFromResource(HashMap<String, ArrayList<File>> resToCopy) throws IOExcep
 
                 ZipEntry entry = availableEntries.get(fromPath);
                 String actualSourcePath = fromPath;
+                SafeZipFile matchedZipFile = null;
                 ResolvedResourceSource resolvedResource = null;
 
                 if (entry == null) {
@@ -87,10 +113,35 @@ void copyFromResource(HashMap<String, ArrayList<File>> resToCopy) throws IOExcep
                     }
                 }
 
+                // 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 && crcByFrom != null) {
+                    Long wantedCrc = crcByFrom.get(fromPath);
+                    if (wantedCrc != null) {
+                        ZipSource matched = crcToEntry.get(wantedCrc);
+                        if (matched != null) {
+                            entry = matched.entry;
+                            matchedZipFile = matched.zipFile;
+                            actualSourcePath = matched.entry.getName();
+                        }
+                    }
+                }
+
                 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;
+                        }
                     }
                 }
 
@@ -104,7 +155,9 @@ void copyFromResource(HashMap<String, ArrayList<File>> resToCopy) throws IOExcep
                         if (lastTarget != null) {
                             UpdateFileUtils.copyFile(lastTarget, target);
                         } else if (entry != null) {
-                            SafeZipFile sourceZipFile = entryToZipFileMap.get(actualSourcePath);
+                            SafeZipFile sourceZipFile = matchedZipFile != null
+                                ? matchedZipFile
+                                : entryToZipFileMap.get(actualSourcePath);
                             if (sourceZipFile == null) {
                                 sourceZipFile = baseZipFile;
                             }
@@ -247,6 +300,9 @@ private ResolvedResourceSource resolveBundledResource(String resourcePath) {
     }
 
     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) {

android/src/main/java/cn/reactnative/modules/update/DownloadTask.java

@@ -40,6 +40,11 @@ private static final class PatchArchiveContents {
         final ArrayList<String> copyFroms = new ArrayList<String>();
         final ArrayList<String> copyTos = new ArrayList<String>();
         final ArrayList<String> deletes = new ArrayList<String>();
+        // Maps a copy source path ("from") to the CRC32 of the file content,
+        // when provided by the manifest ("copiesCrc"). Lets the resource
+        // copier locate the file by content if the path is not present on
+        // device (APK baseline -> AAB install path shortening).
+        final HashMap<String, Long> copyCrcs = new HashMap<String, Long>();
     }
 
     private final Context context;
@@ -140,8 +145,11 @@ private void appendManifestEntries(
         JSONObject manifest,
         ArrayList<String> copyFroms,
         ArrayList<String> copyTos,
-        ArrayList<String> deletes
+        ArrayList<String> deletes,
+        HashMap<String, Long> copyCrcs
     ) throws JSONException {
+        JSONObject copiesCrc = manifest.optJSONObject("copiesCrc");
+
         JSONObject copies = manifest.optJSONObject("copies");
         if (copies != null) {
             Iterator<?> keys = copies.keys();
@@ -153,6 +161,11 @@ private void appendManifestEntries(
                 }
                 copyFroms.add(from);
                 copyTos.add(to);
+                if (copiesCrc != null && copyCrcs != null && copiesCrc.has(to)) {
+                    // Same content => same crc, so grouping multiple "to" under
+                    // one "from" stays consistent.
+                    copyCrcs.put(from, copiesCrc.getLong(to));
+                }
             }
         }
 
@@ -220,7 +233,8 @@ private PatchArchiveContents extractPatchArchive(File archiveFile, File unzipDir
                         manifest,
                         contents.copyFroms,
                         contents.copyTos,
-                        contents.deletes
+                        contents.deletes,
+                        contents.copyCrcs
                     );
                     continue;
                 }
@@ -285,7 +299,7 @@ private void doPatchFromApk() throws IOException, JSONException {
             originBundleFile.delete();
         }
 
-        bundledResourceCopier.copyFromResource(copyList);
+        bundledResourceCopier.copyFromResource(copyList, contents.copyCrcs);
     }
 
     private void doPatchFromPpk() throws IOException, JSONException {