Feature: Add ZIP encoding selection support for browsing archives with non-UTF-8 filenames

src/Files.App.Launcher/Files.App.Launcher.vcxproj

@@ -89,7 +89,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions);_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
   </ItemDefinitionGroup>
@@ -103,7 +103,7 @@
     <ClCompile>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions);_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>

src/Files.App/Data/Models/CurrentInstanceViewModel.cs

@@ -146,6 +146,20 @@ public bool IsPageTypeLibrary
 			}
 		}
 
+		private string? zipEncodingName;
+		public string? ZipEncodingName
+		{
+			get => zipEncodingName;
+			set => SetProperty(ref zipEncodingName, value);
+		}
+
+		private bool isZipEncodingUndetermined;
+		public bool IsZipEncodingUndetermined
+		{
+			get => isZipEncodingUndetermined;
+			set => SetProperty(ref isZipEncodingUndetermined, value);
+		}
+
 		public bool CanCopyPathInPage
 		{
 			get => !isPageTypeMtpDevice && !isPageTypeRecycleBin && isPageTypeNotHome && !isPageTypeSearchResults && !IsPageTypeReleaseNotes && !IsPageTypeSettings;

src/Files.App/UserControls/NavigationToolbar.xaml

@@ -395,6 +395,17 @@
 			Orientation="Horizontal"
 			Spacing="4">
 
+			<!--  ZIP Encoding Selector  -->
+			<ComboBox
+				x:Name="ZipEncodingSelector"
+				Width="140"
+				Height="32"
+				VerticalAlignment="Center"
+				ItemsSource="{x:Bind ViewModel.ZipEncodingOptions, Mode=OneWay}"
+				SelectedItem="{x:Bind ViewModel.SelectedZipEncoding, Mode=TwoWay}"
+				ToolTipService.ToolTip="{helpers:ResourceString Name=Encoding}"
+				Visibility="{x:Bind ViewModel.IsZipEncodingSelectorVisible, Mode=OneWay}" />
+
 			<!--  Shelf Pane  -->
 			<ToggleButton
 				x:Name="ShelfPaneToggleButton"

src/Files.App/Utils/Storage/StorageItems/ZipStorageFile.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Files.Shared.Helpers;
+using ICSharpCode.SharpZipLib.Zip;
 using SevenZip;
 using System.IO;
 using System.Runtime.InteropServices.WindowsRuntime;
@@ -95,6 +96,9 @@ public static IAsyncOperation<BaseStorageFile> FromPathAsync(string path)
 
 		public override IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode accessMode)
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return OpenWithEncodingAsync(accessMode);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IRandomAccessStream>(async () =>
 			{
 				bool rw = accessMode is FileAccessMode.ReadWrite;
@@ -136,11 +140,53 @@ public override IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode ac
 				throw new NotSupportedException("Can't open zip file as RW");
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
+		private IAsyncOperation<IRandomAccessStream> OpenWithEncodingAsync(FileAccessMode accessMode)
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IRandomAccessStream>(() =>
+				{
+					bool rw = accessMode is FileAccessMode.ReadWrite;
+					if (rw)
+						throw new NotSupportedException("Can't open zip file as RW");
+
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetName = GetEntryRelativePath();
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						if (!entry.IsFile)
+							continue;
+
+						if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+						{
+							var ms = new MemoryStream();
+							using (var zipStream = zipFile.GetInputStream(entry))
+							{
+								zipStream.CopyTo(ms);
+							}
+							ms.Position = 0;
+							return new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+						}
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode accessMode, StorageOpenOptions options)
 			=> OpenAsync(accessMode);
 
 		public override IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsync()
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return OpenReadWithEncodingAsync();
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IRandomAccessStreamWithContentType>(async () =>
 			{
 				if (Path == containerPath)
@@ -178,8 +224,47 @@ public override IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsyn
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadWithEncodingAsync()
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IRandomAccessStreamWithContentType>(() =>
+				{
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetName = GetEntryRelativePath();
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						if (!entry.IsFile)
+							continue;
+
+						if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+						{
+							var ms = new MemoryStream();
+							using (var zipStream = zipFile.GetInputStream(entry))
+							{
+								zipStream.CopyTo(ms);
+							}
+							ms.Position = 0;
+							var nsStream = new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+							return new StreamWithContentType(nsStream);
+						}
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<IInputStream> OpenSequentialReadAsync()
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return OpenSequentialReadWithEncodingAsync();
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IInputStream>(async () =>
 			{
 				if (Path == containerPath)
@@ -215,6 +300,41 @@ public override IAsyncOperation<IInputStream> OpenSequentialReadAsync()
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncOperation<IInputStream> OpenSequentialReadWithEncodingAsync()
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IInputStream>(() =>
+				{
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetName = GetEntryRelativePath();
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						if (!entry.IsFile)
+							continue;
+
+						if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+						{
+							var ms = new MemoryStream();
+							using (var zipStream = zipFile.GetInputStream(entry))
+							{
+								zipStream.CopyTo(ms);
+							}
+							ms.Position = 0;
+							return new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+						}
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync()
 			=> throw new NotSupportedException();
 		public override IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(StorageOpenOptions options)
@@ -226,6 +346,9 @@ public override IAsyncOperation<BaseStorageFile> CopyAsync(IStorageFolder destin
 			=> CopyAsync(destinationFolder, desiredNewName, NameCollisionOption.FailIfExists);
 		public override IAsyncOperation<BaseStorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return CopyWithEncodingAsync(destinationFolder, desiredNewName, option);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<BaseStorageFile>(async () =>
 			{
 				using SevenZipExtractor zipFile = await OpenZipFileAsync();
@@ -264,8 +387,57 @@ await SafetyExtensions.WrapAsync(() => zipFile.ExtractFileAsync(entry.Index, out
 				}
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
+
+		private IAsyncOperation<BaseStorageFile> CopyWithEncodingAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
+		{
+			return AsyncInfo.Run(async (cancellationToken) =>
+			{
+				using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+				if (!string.IsNullOrEmpty(Credentials.Password))
+					zipFile.Password = Credentials.Password;
+
+				var targetName = GetEntryRelativePath();
+
+				foreach (ZipEntry entry in zipFile)
+				{
+					if (!entry.IsFile)
+						continue;
+
+					if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+					{
+						var ms = new MemoryStream();
+						using (var zipStream = zipFile.GetInputStream(entry))
+						{
+							zipStream.CopyTo(ms);
+						}
+						ms.Position = 0;
+
+						var destFolder = destinationFolder.AsBaseStorageFolder();
+						if (destFolder is ICreateFileWithStream cwsf)
+						{
+							using var inStream = new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+							return await cwsf.CreateFileAsync(inStream.AsStreamForRead(), desiredNewName, option.Convert());
+						}
+						else
+						{
+							var destFile = await destFolder.CreateFileAsync(desiredNewName, option.Convert());
+							await using var outStream = await destFile.OpenStreamForWriteAsync();
+							ms.Position = 0;
+							ms.CopyTo(outStream);
+							return destFile;
+						}
+					}
+				}
+
+				return null;
+			});
+		}
 		public override IAsyncAction CopyAndReplaceAsync(IStorageFile fileToReplace)
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return CopyAndReplaceWithEncodingAsync(fileToReplace);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.WrapAsync(async () =>
 			{
 				using SevenZipExtractor zipFile = await OpenZipFileAsync();
@@ -288,6 +460,36 @@ public override IAsyncAction CopyAndReplaceAsync(IStorageFile fileToReplace)
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncAction CopyAndReplaceWithEncodingAsync(IStorageFile fileToReplace)
+		{
+			return AsyncInfo.Run(async (cancellationToken) =>
+			{
+				using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+				if (!string.IsNullOrEmpty(Credentials.Password))
+					zipFile.Password = Credentials.Password;
+
+				var targetName = GetEntryRelativePath();
+
+				foreach (ZipEntry entry in zipFile)
+				{
+					if (!entry.IsFile)
+						continue;
+
+					if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+					{
+						using var hDestFile = fileToReplace.CreateSafeFileHandle(FileAccess.ReadWrite);
+						await using (var outStream = new FileStream(hDestFile, FileAccess.Write))
+						using (var zipStream = zipFile.GetInputStream(entry))
+						{
+							zipStream.CopyTo(outStream);
+						}
+						return;
+					}
+				}
+			});
+		}
+
 		public override IAsyncAction MoveAsync(IStorageFolder destinationFolder)
 			=> throw new NotSupportedException();
 		public override IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName)
@@ -399,6 +601,12 @@ public override IAsyncOperation<StorageItemThumbnail> GetThumbnailAsync(Thumbnai
 		public override IAsyncOperation<StorageItemThumbnail> GetThumbnailAsync(ThumbnailMode mode, uint requestedSize, ThumbnailOptions options)
 			=> Task.FromResult<StorageItemThumbnail>(null).AsAsyncOperation();
 
+		private string GetEntryRelativePath()
+		{
+			var relative = Path.Substring(containerPath.Length).Trim('\\', '/');
+			return relative.Replace('\\', '/');
+		}
+
 		private static bool CheckAccess(string path)
 		{
 			try