diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/BuildArchive.cs b/src/Xamarin.Android.Build.Tasks/Tasks/BuildArchive.cs index db57c4eb989..4b3389e92e2 100644 --- a/src/Xamarin.Android.Build.Tasks/Tasks/BuildArchive.cs +++ b/src/Xamarin.Android.Build.Tasks/Tasks/BuildArchive.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.IO; using System.Linq; +using System.Runtime.InteropServices; using Microsoft.Android.Build.Tasks; using Microsoft.Build.Framework; using Xamarin.Tools.Zip; @@ -32,6 +33,8 @@ public class BuildArchive : AndroidTask public string? UncompressedFileExtensions { get; set; } + public bool UseLibZipSharp { get; set; } + public string? ZipFlushFilesLimit { get; set; } public string? ZipFlushSizeLimit { get; set; } @@ -43,8 +46,10 @@ public class BuildArchive : AndroidTask public override bool RunTask () { + var is_aab = string.Compare (AndroidPackageFormat, "aab", true) == 0; + // Nothing needs to be compressed with app bundles. BundleConfig.json specifies the final compression mode. - if (string.Compare (AndroidPackageFormat, "aab", true) == 0) + if (is_aab) uncompressedMethod = CompressionMethod.Default; var refresh = true; @@ -57,7 +62,7 @@ public override bool RunTask () refresh = false; } - using var apk = new ZipArchiveEx (ApkOutputPath, FileMode.Open); + using var apk = ZipArchiveDotNet.Create (Log, ApkOutputPath, System.IO.Compression.ZipArchiveMode.Update, ShouldFallbackToLibZipSharp ()); // Set up AutoFlush if (int.TryParse (ZipFlushFilesLimit, out int flushFilesLimit)) { @@ -73,10 +78,9 @@ public override bool RunTask () var existingEntries = new List (); if (refresh) { - for (var i = 0; i < apk.Archive.EntryCount; i++) { - var entry = apk.Archive.ReadEntry ((ulong) i); - Log.LogDebugMessage ($"Registering item {entry.FullName}"); - existingEntries.Add (entry.FullName); + foreach (var entry in apk.GetAllEntryNames ()) { + Log.LogDebugMessage ($"Registering item {entry}"); + existingEntries.Add (entry); } } @@ -98,6 +102,11 @@ public override bool RunTask () Log.LogDebugMessage ($"Fixing up malformed entry `{entry.FullName}` -> `{entryName}`"); } + if (entryName == "AndroidManifest.xml" && is_aab) { + Log.LogDebugMessage ("Renaming AndroidManifest.xml to manifest/AndroidManifest.xml"); + entryName = "manifest/AndroidManifest.xml"; + } + Log.LogDebugMessage ($"Deregistering item {entryName}"); existingEntries.Remove (entryName); @@ -106,24 +115,28 @@ public override bool RunTask () continue; } - if (apk.Archive.ContainsEntry (entryName)) { - ZipEntry e = apk.Archive.ReadEntry (entryName); + if (apk.ContainsEntry (entryName)) { + var e = apk.GetEntry (entryName); // check the CRC values as the ModifiedDate is always 01/01/1980 in the aapt generated file. if (entry.CRC == e.CRC && entry.CompressedSize == e.CompressedSize) { Log.LogDebugMessage ($"Skipping {entryName} from {ApkInputPath} as its up to date."); continue; } + + // Delete the existing entry so we can replace it with the new one. + apk.DeleteEntry (entryName); } var ms = new MemoryStream (); entry.Extract (ms); + ms.Position = 0; Log.LogDebugMessage ($"Refreshing {entryName} from {ApkInputPath}"); - apk.Archive.AddStream (ms, entryName, compressionMethod: entry.CompressionMethod); + apk.AddEntry (ms, entryName, entry.CompressionMethod.ToCompressionLevel ()); } } } - apk.FixupWindowsPathSeparators ((a, b) => Log.LogDebugMessage ($"Fixing up malformed entry `{a}` -> `{b}`")); + apk.FixupWindowsPathSeparators (Log); // Add the files to the apk foreach (var file in FilesToAddToArchive) { @@ -135,6 +148,8 @@ public override bool RunTask () return !Log.HasLoggedErrors; } + apk_path = apk_path.Replace ('\\', '/'); + // This is a temporary hack for adding files directly from inside a .jar/.aar // into the APK. Eventually another task should be writing them to disk and just // passing us a filename like everything else. @@ -145,7 +160,7 @@ public override bool RunTask () // eg: "obj/myjar.jar#myfile.txt" var jar_file_path = disk_path.Substring (0, disk_path.Length - (jar_entry_name.Length + 1)); - if (apk.Archive.Any (ze => ze.FullName == apk_path)) { + if (apk.ContainsEntry (apk_path)) { Log.LogDebugMessage ("Failed to add jar entry {0} from {1}: the same file already exists in the apk", jar_entry_name, Path.GetFileName (jar_file_path)); continue; } @@ -165,7 +180,7 @@ public override bool RunTask () } Log.LogDebugMessage ($"Adding {jar_entry_name} from {jar_file_path} as the archive file is out of date."); - apk.AddEntryAndFlush (data, apk_path); + apk.AddEntry (data, apk_path); } continue; @@ -180,30 +195,71 @@ public override bool RunTask () if (string.Compare (Path.GetFileName (entry), "AndroidManifest.xml", StringComparison.OrdinalIgnoreCase) == 0) continue; - Log.LogDebugMessage ($"Removing {entry} as it is not longer required."); - apk.Archive.DeleteEntry (entry); + Log.LogDebugMessage ($"Removing {entry} as it is no longer required."); + apk.DeleteEntry (entry); } - if (string.Compare (AndroidPackageFormat, "aab", true) == 0) + if (is_aab) FixupArchive (apk); return !Log.HasLoggedErrors; } - bool AddFileToArchiveIfNewer (ZipArchiveEx apk, string file, string inArchivePath, ITaskItem item, List existingEntries) + // .NET Framework has a bug where it doesn't handle uncompressed files correctly. + // It writes them as "compressed" (DEFLATE) but with a compression level of 0. This causes + // issues with Android, which expect uncompressed files to be stored correctly. + // We can work around this by using LibZipSharp, which doesn't have this bug. + // This is only necessary if we're on .NET Framework (MSBuild in VSWin) and we have uncompressed files. + bool ShouldFallbackToLibZipSharp () { - var compressionMethod = GetCompressionMethod (item); - existingEntries.Remove (inArchivePath.Replace (Path.DirectorySeparatorChar, '/')); + // Explicitly requested via MSBuild property. + if (UseLibZipSharp) { + Log.LogDebugMessage ("Falling back to LibZipSharp because '$(_AndroidUseLibZipSharp)' is 'true'."); + return true; + } - if (apk.SkipExistingFile (file, inArchivePath, compressionMethod)) { - Log.LogDebugMessage ($"Skipping {file} as the archive file is up to date."); + // .NET 6+ handles uncompressed files correctly, so we don't need to fallback. + if (RuntimeInformation.FrameworkDescription == ".NET") { + Log.LogDebugMessage ("Using System.IO.Compression because we're running on .NET 6+."); return false; } - Log.LogDebugMessage ($"Adding {file} as the archive file is out of date."); - apk.AddFileAndFlush (file, inArchivePath, compressionMethod); + // Nothing is going to get written uncompressed, so we don't need to fallback. + if (uncompressedMethod != CompressionMethod.Store) { + Log.LogDebugMessage ("Using System.IO.Compression because uncompressedMethod isn't 'Store'."); + return false; + } - return true; + // No uncompressed file extensions were specified, so we don't need to fallback. + if (UncompressedFileExtensionsSet.Count == 0) { + Log.LogDebugMessage ("Using System.IO.Compression because no uncompressed file extensions were specified."); + return false; + } + + // See if any of the files to be added need to be uncompressed. + foreach (var file in FilesToAddToArchive) { + var file_path = file.ItemSpec; + + // Handle files from inside a .jar/.aar + if (file.GetMetadataOrDefault ("JavaArchiveEntry", (string?)null) is string jar_entry_name) + file_path = jar_entry_name; + + if (UncompressedFileExtensionsSet.Contains (Path.GetExtension (file_path))) { + Log.LogDebugMessage ($"Falling back to LibZipSharp because '{file_path}' needs to be stored uncompressed."); + return true; + } + } + + Log.LogDebugMessage ("Using System.IO.Compression because no files need to be stored uncompressed."); + return false; + } + + bool AddFileToArchiveIfNewer (IZipArchive apk, string file, string inArchivePath, ITaskItem item, List existingEntries) + { + var compressionMethod = GetCompressionLevel (item); + existingEntries.Remove (inArchivePath.Replace (Path.DirectorySeparatorChar, '/')); + + return apk.AddFileIfChanged (Log, file, inArchivePath, compressionMethod); } /// @@ -211,32 +267,24 @@ bool AddFileToArchiveIfNewer (ZipArchiveEx apk, string file, string inArchivePat /// I see no way to change this behavior, so we can move the file for now: /// https://github.com/aosp-mirror/platform_frameworks_base/blob/e80b45506501815061b079dcb10bf87443bd385d/tools/aapt2/LoadedApk.h#L34 /// - void FixupArchive (ZipArchiveEx zip) + void FixupArchive (IZipArchive zip) { - if (!zip.Archive.ContainsEntry ("AndroidManifest.xml")) { + if (!zip.ContainsEntry ("AndroidManifest.xml")) { Log.LogDebugMessage ($"No AndroidManifest.xml. Skipping Fixup"); return; } - var entry = zip.Archive.ReadEntry ("AndroidManifest.xml"); Log.LogDebugMessage ($"Fixing up AndroidManifest.xml to be manifest/AndroidManifest.xml."); - if (zip.Archive.ContainsEntry ("manifest/AndroidManifest.xml")) - zip.Archive.DeleteEntry (zip.Archive.ReadEntry ("manifest/AndroidManifest.xml")); + if (zip.ContainsEntry ("manifest/AndroidManifest.xml")) + zip.DeleteEntry ("manifest/AndroidManifest.xml"); - entry.Rename ("manifest/AndroidManifest.xml"); + zip.MoveEntry ("AndroidManifest.xml", "manifest/AndroidManifest.xml"); } - CompressionMethod GetCompressionMethod (ITaskItem item) + System.IO.Compression.CompressionLevel GetCompressionLevel (ITaskItem item) { - var compression = item.GetMetadataOrDefault ("Compression", ""); - - if (compression.HasValue ()) { - if (Enum.TryParse (compression, out CompressionMethod result)) - return result; - } - - return UncompressedFileExtensionsSet.Contains (Path.GetExtension (item.ItemSpec)) ? uncompressedMethod : CompressionMethod.Default; + return (UncompressedFileExtensionsSet.Contains (Path.GetExtension (item.ItemSpec)) ? uncompressedMethod : CompressionMethod.Default).ToCompressionLevel (); } HashSet ParseUncompressedFileExtensions () diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/UtilityExtensions.cs b/src/Xamarin.Android.Build.Tasks/Utilities/UtilityExtensions.cs new file mode 100644 index 00000000000..a566a6b754f --- /dev/null +++ b/src/Xamarin.Android.Build.Tasks/Utilities/UtilityExtensions.cs @@ -0,0 +1,46 @@ +using System; +using System.IO; +using System.IO.Compression; +using Xamarin.Tools.Zip; + +namespace Xamarin.Android.Tasks; + +static class UtilityExtensions +{ + public static System.IO.Compression.CompressionLevel ToCompressionLevel (this CompressionMethod method) + { + switch (method) { + case CompressionMethod.Store: + return System.IO.Compression.CompressionLevel.NoCompression; + case CompressionMethod.Default: + case CompressionMethod.Deflate: + return System.IO.Compression.CompressionLevel.Optimal; + default: + throw new ArgumentOutOfRangeException (nameof (method), method, null); + } + } + + public static CompressionMethod ToCompressionMethod (this System.IO.Compression.CompressionLevel level) + { + switch (level) { + case System.IO.Compression.CompressionLevel.NoCompression: + return CompressionMethod.Store; + case System.IO.Compression.CompressionLevel.Optimal: + return CompressionMethod.Deflate; + default: + throw new ArgumentOutOfRangeException (nameof (level), level, null); + } + } + + public static FileMode ToFileMode (this ZipArchiveMode mode) + { + switch (mode) { + case ZipArchiveMode.Create: + return FileMode.Create; + case ZipArchiveMode.Update: + return FileMode.Open; + default: + throw new ArgumentOutOfRangeException (nameof (mode), mode, null); + } + } +} diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveDotNet.cs b/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveDotNet.cs new file mode 100644 index 00000000000..12a84f83ab4 --- /dev/null +++ b/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveDotNet.cs @@ -0,0 +1,263 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.IO.Compression; +using System.Linq; +using System.Reflection; +using Microsoft.Android.Build.Tasks; +using Microsoft.Build.Utilities; + +namespace Xamarin.Android.Tasks; + +interface IZipArchive : IDisposable +{ + int ZipFlushFilesLimit { get; set; } + int ZipFlushSizeLimit { get; set; } + + void AddEntry (byte [] data, string apkPath); + void AddEntry (Stream stream, string apkPath, CompressionLevel compression); + bool AddFileIfChanged (TaskLoggingHelper log, string filename, string archiveFileName, CompressionLevel compression); + bool ContainsEntry (string entryPath); + void DeleteEntry (string entry); + void FixupWindowsPathSeparators (TaskLoggingHelper log); + IEnumerable GetAllEntryNames (); + IZipArchiveEntry GetEntry (string entryName); + void MoveEntry (string oldEntry, string newEntry); +} + +interface IZipArchiveEntry +{ + uint CRC { get; } + ulong CompressedSize { get; } +} + +class ZipArchiveDotNet : IZipArchive +{ + const int DEFAULT_FLUSH_SIZE_LIMIT = 100 * 1024 * 1024; + const int DEFAULT_FLUSH_FILES_LIMIT = 512; + + // ZipFile seems to be performant enough that we have not currently implemented a flush mechanism. + public int ZipFlushSizeLimit { get; set; } = DEFAULT_FLUSH_SIZE_LIMIT; + public int ZipFlushFilesLimit { get; set; } = DEFAULT_FLUSH_FILES_LIMIT; + + public ZipArchive Archive { get; } + + static readonly FieldInfo? crc_field; + static readonly FieldInfo? comp_field; + + // This is private to ensure the only way to create an instance is through the Create method. + ZipArchiveDotNet (string archive, ZipArchiveMode mode) + { + Archive = ZipFile.Open (archive, mode); + } + + static ZipArchiveDotNet () + { + // netstandard2.0 does not provide a way to access a ZipArchiveEntry's CRC or compresion level. + // We need to use reflection to access the private fields. + + // These private fields exist on both .NET Framework 4.7.2 and .NET 9.0. If they are not found, + // we will return a ZipArchiveEx which uses LibZipSharp instead. + crc_field = typeof (ZipArchiveEntry).GetField ("_crc32", BindingFlags.NonPublic | BindingFlags.Instance); + comp_field = typeof (ZipArchiveEntry).GetField ("_storedCompressionMethod", BindingFlags.NonPublic | BindingFlags.Instance); + } + + public static IZipArchive Create (TaskLoggingHelper log, string archive, ZipArchiveMode mode, bool fallback) + { + if (fallback) { + log.LogDebugMessage ($"ZipArchiveDotNet: Falling back to LibZipSharp as requested."); + return new ZipArchiveEx (archive, mode.ToFileMode ()); + } + + if (crc_field is null) { + log.LogDebugMessage ($"ZipArchiveDotNet: Could not find private CRC field, falling back to LibZipSharp."); + return new ZipArchiveEx (archive, mode.ToFileMode ()); + } + + if (comp_field is null) { + log.LogDebugMessage ($"ZipArchiveDotNet: Could not find private CompressionMethod field, falling back to LibZipSharp."); + return new ZipArchiveEx (archive, mode.ToFileMode ()); + } + + log.LogDebugMessage ($"ZipArchiveDotNet: Using ZipArchiveDotNet."); + return new ZipArchiveDotNet (archive, mode); + } + + public void AddEntry (byte [] data, string apkPath) + { + var entry = Archive.CreateEntry (apkPath); + + using (var stream = entry.Open ()) + stream.Write (data, 0, data.Length); + } + + public void AddEntry (Stream stream, string apkPath, CompressionLevel compression) + { + var entry = Archive.CreateEntry (apkPath, compression); + + using (var entry_stream = entry.Open ()) + stream.CopyTo (entry_stream); + } + + public bool AddFileIfChanged (TaskLoggingHelper log, string filename, string archiveFileName, CompressionLevel compression) + { + if (!FileNeedsUpdating (log, filename, archiveFileName, compression)) + return false; + + DeleteEntry (archiveFileName); + Archive.CreateEntryFromFile (filename, archiveFileName, compression); + + return true; + } + + public bool ContainsEntry (string entryName) + { + return Archive.GetEntry (entryName) is not null; + } + + public void DeleteEntry (string entryName) + { + var entry = Archive.GetEntry (entryName); + + entry?.Delete (); + } + + /// + /// HACK: aapt2 is creating zip entries on Windows such as `assets\subfolder/asset2.txt` + /// + public void FixupWindowsPathSeparators (TaskLoggingHelper log) + { + var malformed_entries = Archive.Entries.Where (entry => entry.FullName.Contains ('\\')).ToList (); + + foreach (var entry in malformed_entries) { + var name = entry.FullName.Replace ('\\', '/'); + if (name != entry.FullName) { + log.LogDebugMessage ($"Fixing up malformed entry `{entry.FullName}` -> `{name}`"); + MoveEntry (entry.FullName, name); + } + } + } + + public IEnumerable GetAllEntryNames () + { + return Archive.Entries.Select (entry => entry.FullName); + } + + public IZipArchiveEntry GetEntry (string entryName) + { + var entry = Archive.GetEntry (entryName); + + if (entry is null) + throw new ArgumentOutOfRangeException (nameof (entryName)); + + return new ZipArchiveEntryDotNet (entry, GetCrc32 (entry)); + } + + public void Dispose () + { + Archive.Dispose (); + } + + public void MoveEntry (string oldPath, string newPath) + { + var old_entry = Archive.GetEntry (oldPath); + + if (old_entry is null) + return; + + var new_entry = Archive.CreateEntry (newPath); + + using (var oldStream = old_entry.Open ()) + using (var newStream = new_entry.Open ()) + oldStream.CopyTo (newStream); + + old_entry.Delete (); + } + + bool FileNeedsUpdating (TaskLoggingHelper log, string filename, string archiveFileName, CompressionLevel compression) + { + var entry = Archive.GetEntry (archiveFileName); + + if (entry is null) { + log.LogDebugMessage ($"Adding {filename} as it doesn't already exist."); + return true; + } + + var stored_compression = GetCompressionLevel (entry); + + if (stored_compression != compression) { + log.LogDebugMessage ($"Updating {filename} as the compression level changed: existing - '{stored_compression}', requested - '{compression}'."); + return true; + } + + var last_write = File.GetLastWriteTimeUtc (filename); + var file_write_dos_time = DateTimeToDosTime (last_write); + var zip_write_dos_time = DateTimeToDosTime (entry.LastWriteTime.UtcDateTime); + + if (DateTimeToDosTime (entry.LastWriteTime.UtcDateTime) < DateTimeToDosTime (last_write)) { + log.LogDebugMessage ($"Updating {filename} as the file write time is newer: file in zip - '{zip_write_dos_time}', file on disk - '{file_write_dos_time}'."); + return true; + } + + log.LogDebugMessage ($"Skipping {filename} as the archive file is up to date."); + return false; + } + + static uint GetCrc32 (ZipArchiveEntry entry) + { + if (crc_field is null) + throw new NotSupportedException ("This method is not supported on this platform."); + + return (uint) crc_field.GetValue (entry); + } + + static CompressionLevel GetCompressionLevel (ZipArchiveEntry entry) + { + if (comp_field is null) + throw new NotSupportedException ("This method is not supported on this platform."); + + var level = comp_field.GetValue (entry).ToString (); + + switch (level) { + case "Stored": + return CompressionLevel.NoCompression; + case "Deflate": + return CompressionLevel.Optimal; + default: + throw new NotSupportedException ($"Unsupported compression level: {level}"); + } + } + + // System.IO.Compression.ZipArchive apparently only provides a 2 second granularity for the LastWriteTime. + // This should be fine, it would be nearly impossible for someone to complete a build, make a change, + // and rebuild in under 2 seconds. + // This is a port of the DateTimeToDosTime method from System.IO.Compression.ZipHelper + // https://github.com/dotnet/runtime/blob/373f048bae3c46810bc030ed7c1ee0568ee5ecc0/src/libraries/System.IO.Compression/src/System/IO/Compression/ZipHelper.cs#L88 + const int ValidZipDate_YearMin = 1980; + + static uint DateTimeToDosTime (DateTime dateTime) + { + int ret = ((dateTime.Year - ValidZipDate_YearMin) & 0x7F); + ret = (ret << 4) + dateTime.Month; + ret = (ret << 5) + dateTime.Day; + ret = (ret << 5) + dateTime.Hour; + ret = (ret << 6) + dateTime.Minute; + ret = (ret << 5) + (dateTime.Second / 2); // only 5 bits for second, so we only have a granularity of 2 sec. + return (uint) ret; + } + + class ZipArchiveEntryDotNet : IZipArchiveEntry + { + readonly ZipArchiveEntry entry; + readonly uint crc; + + public uint CRC => crc; + public ulong CompressedSize => (ulong) entry.CompressedLength; + + public ZipArchiveEntryDotNet (ZipArchiveEntry entry, uint crc) + { + this.entry = entry; + this.crc = crc; + } + } +} diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveEx.cs b/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveEx.cs index 54e510218ad..21ef964fe12 100644 --- a/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveEx.cs +++ b/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveEx.cs @@ -1,11 +1,14 @@ -using System; +using System; +using System.Collections.Generic; using System.IO; using System.Linq; +using Microsoft.Android.Build.Tasks; +using Microsoft.Build.Utilities; using Xamarin.Tools.Zip; namespace Xamarin.Android.Tasks { - public class ZipArchiveEx : IDisposable + public class ZipArchiveEx : IZipArchive { const int DEFAULT_FLUSH_SIZE_LIMIT = 100 * 1024 * 1024; @@ -235,5 +238,71 @@ protected virtual void Dispose(bool disposing) { } } } + + public void AddEntry (byte [] data, string apkPath) + => AddEntryAndFlush (data, apkPath); + + public void AddEntry (Stream stream, string apkPath, System.IO.Compression.CompressionLevel compression) + => AddEntryAndFlush (apkPath, stream, compression.ToCompressionMethod ()); + + public bool AddFileIfChanged (TaskLoggingHelper log, string filename, string archiveFileName, System.IO.Compression.CompressionLevel compression) + { + var compressionMethod = compression.ToCompressionMethod (); + + if (!SkipExistingFile (filename, archiveFileName, compressionMethod)) { + AddFileAndFlush (filename, archiveFileName, compressionMethod); + log.LogDebugMessage ($"Adding {filename} as the archive file is out of date."); + return true; + } + + log.LogDebugMessage ($"Skipping {filename} as the archive file is up to date."); + + return false; + } + + public bool ContainsEntry (string entryPath) + => zip.ContainsEntry (entryPath); + + public void DeleteEntry (string entry) + => zip.DeleteEntry (entry); + + public void FixupWindowsPathSeparators (TaskLoggingHelper log) + => FixupWindowsPathSeparators ((a, b) => log.LogDebugMessage ($"Fixing up malformed entry `{a}` -> `{b}`")); + + public IEnumerable GetAllEntryNames () + { + for (var i = 0; i < Archive.EntryCount; i++) { + var entry = Archive.ReadEntry ((ulong) i); + yield return entry.FullName; + } + } + + IZipArchiveEntry IZipArchive.GetEntry (string entryName) + { + return new ZipArchiveEntryEx (zip.ReadEntry (entryName)); + } + + void IZipArchive.MoveEntry (string oldEntry, string newEntry) + { + if (Archive.ContainsEntry (newEntry)) + Archive.DeleteEntry (Archive.ReadEntry (newEntry)); + + var entry = zip.ReadEntry (oldEntry); + entry.Rename (newEntry); + } + } + + class ZipArchiveEntryEx : IZipArchiveEntry + { + readonly ZipEntry entry; + + public ZipArchiveEntryEx (ZipEntry entry) + { + this.entry = entry; + } + + public uint CRC => entry.CRC; + + public ulong CompressedSize => entry.CompressedSize; } } diff --git a/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveFileListBuilder.cs b/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveFileListBuilder.cs deleted file mode 100644 index cdaf609ffc3..00000000000 --- a/src/Xamarin.Android.Build.Tasks/Utilities/ZipArchiveFileListBuilder.cs +++ /dev/null @@ -1,67 +0,0 @@ -#nullable enable - -using System; -using System.Collections.Generic; -using System.IO; -using Microsoft.Build.Framework; -using Microsoft.Build.Utilities; -using Xamarin.Tools.Zip; - -namespace Xamarin.Android.Tasks; - -// This temporary class has a nonsensical API to allow it to be a drop-in replacement -// for ZipArchiveEx. This allows us to refactor with smaller diffs that can be -// reviewed easier. This class should not exist in this form in the final state. -public class ZipArchiveFileListBuilder : IDisposable -{ - public List ApkFiles { get; } = []; - - public ZipArchiveFileListBuilder (string archive, FileMode filemode) - { - } - - public void Dispose () - { - // No-op - } - - public void Flush () - { - // No-op - } - - public void AddFileAndFlush (string filename, string archiveFileName, CompressionMethod compressionMethod) - { - var item = new TaskItem (filename); - - item.SetMetadata ("ArchivePath", archiveFileName); - item.SetMetadata ("Compression", compressionMethod.ToString ()); - - ApkFiles.Add (item); - } - - public void AddJavaEntryAndFlush (string javaFilename, string javaEntryName, string archiveFileName) - { - // An item's ItemSpec must be unique so use both the jar file name and the entry name - var item = new TaskItem ($"{javaFilename}#{javaEntryName}"); - item.SetMetadata ("ArchivePath", archiveFileName); - item.SetMetadata ("JavaArchiveEntry", javaEntryName); - - ApkFiles.Add (item); - } - - public void FixupWindowsPathSeparators (Action onRename) - { - // No-op - } - - public bool SkipExistingFile (string file, string fileInArchive, CompressionMethod compressionMethod) - { - return false; - } - - public bool SkipExistingEntry (ZipEntry sourceEntry, string fileInArchive) - { - return false; - } -} diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets index f2eb3021660..84bc8a00c9a 100644 --- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets +++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets @@ -2182,6 +2182,7 @@ because xbuild doesn't support framework reference assemblies. ApkOutputPath="$(_ApkOutputPath)" FilesToAddToArchive="@(FilesToAddToArchive)" UncompressedFileExtensions="$(AndroidStoreUncompressedFileExtensions)" + UseLibZipSharp="$(_AndroidUseLibZipSharp)" ZipFlushFilesLimit="$(_ZipFlushFilesLimit)" ZipFlushSizeLimit="$(_ZipFlushSizeLimit)" /> @@ -2313,6 +2314,7 @@ because xbuild doesn't support framework reference assemblies. ApkOutputPath="$(_ApkOutputPath)" FilesToAddToArchive="@(FilesToAddToArchive)" UncompressedFileExtensions="$(AndroidStoreUncompressedFileExtensions)" + UseLibZipSharp="$(_AndroidUseLibZipSharp)" ZipFlushFilesLimit="$(_ZipFlushFilesLimit)" ZipFlushSizeLimit="$(_ZipFlushSizeLimit)" />