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>

Author: sunnylqm

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

@@ -26,22 +26,32 @@ final class BundledResourceCopier {
     private static final class ResolvedResourceSource {
         final int resourceId;
         final String assetPath;
+        final TypedValue typedValue;
 
-        ResolvedResourceSource(int resourceId, String assetPath) {
+        ResolvedResourceSource(int resourceId, String assetPath, TypedValue typedValue) {
             this.resourceId = resourceId;
             this.assetPath = assetPath;
+            this.typedValue = typedValue;
         }
     }
 
     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 -> entry name. 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, String> crcToEntryName = new HashMap<Long, String>();
 
         try {
             for (String apkPath : apkPaths) {
@@ -55,6 +65,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 && !crcToEntryName.containsKey(crc)) {
+                        crcToEntryName.put(crc, entryName);
+                    }
                 }
             }
 
@@ -87,6 +101,20 @@ 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) {
+                        String matchedEntry = crcToEntryName.get(wantedCrc);
+                        if (matchedEntry != null) {
+                            entry = availableEntries.get(matchedEntry);
+                            actualSourcePath = matchedEntry;
+                        }
+                    }
+                }
+
                 if (entry == null) {
                     resolvedResource = resolveBundledResource(fromPath);
                     if (resolvedResource != null) {
@@ -243,12 +271,15 @@ private ResolvedResourceSource resolveBundledResource(String resourcePath) {
             assetPath = assetPath.substring(1);
         }
 
-        return new ResolvedResourceSource(resourceId, assetPath);
+        return new ResolvedResourceSource(resourceId, assetPath, typedValue);
     }
 
     private InputStream openResolvedResourceStream(ResolvedResourceSource source) throws IOException {
         try {
-            return context.getResources().openRawResource(source.resourceId);
+            // Use the density-resolved TypedValue so we open the exact variant
+            // that was requested, instead of openRawResource(id) which would
+            // fall back to the device's current configuration density.
+            return context.getResources().openRawResource(source.resourceId, source.typedValue);
         } catch (Resources.NotFoundException e) {
             throw new IOException("Unable to open resolved resource: " + source.assetPath, 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 {