[WIP] This commit will break a LOT of tests

I need to change the assembly name mangling characters as, as it
appears, Android doesn't like `#` or `%` when deploying a Debug build
apk with `extractNativeLibs=true` in the manifest.  In such case, none
of the entries with `#` and `%` characters anywhere in the name (also
tested `!`) will be extracted to the filesystem.

TBC tomorrow, the great quest to find the Character That Works.

src/Xamarin.Android.Build.Tasks/Tasks/BuildApk.cs

@@ -470,6 +470,11 @@ void AddAssembliesFromCollection (ITaskItem[] assemblies)
 
 			void DoAddAssembliesFromArchCollection (Dictionary<string, ITaskItem> assemblies)
 			{
+				// In the "all assemblies are per-RID" world, assemblies, pdb and config are disguised as shared libraries (that is,
+				// their names end with the .so extension) so that Android allows us to put them in the `lib/{ARCH}` directory.
+				// For this reason, they have to be treated just like other .so files, as far as compression rules are concerned.
+				// Thus, we no longer just store them in the apk but we call the `GetCompressionMethod` method to find out whether
+				// or not we're supposed to compress .so files.
 				foreach (ITaskItem assembly in assemblies.Values) {
 					if (MonoAndroidHelper.IsReferenceAssembly (assembly.ItemSpec)) {
 						Log.LogCodedWarning ("XA0107", assembly.ItemSpec, 0, Properties.Resources.XA0107, assembly.ItemSpec);
@@ -482,7 +487,7 @@ void DoAddAssembliesFromArchCollection (Dictionary<string, ITaskItem> assemblies
 					if (UseAssemblyStore) {
 						storeAssemblyInfo = new AssemblyStoreAssemblyInfo (sourcePath, assembly);
 					} else {
-						AddFileToArchiveIfNewer (apk, sourcePath, assemblyPath, compressionMethod: UncompressedMethod);
+						AddFileToArchiveIfNewer (apk, sourcePath, assemblyPath, compressionMethod: GetCompressionMethod (assemblyPath));
 					}
 
 					// Try to add config if exists
@@ -508,11 +513,12 @@ void DoAddAssembliesFromArchCollection (Dictionary<string, ITaskItem> assemblies
 							if (UseAssemblyStore) {
 								storeAssemblyInfo.SymbolsFile = new FileInfo (symbolsPath);
 							} else {
+								string archiveSymbolsPath = assemblyDirectory + MonoAndroidHelper.MakeDiscreteAssembliesEntryName (Path.GetFileName (symbols));
 								AddFileToArchiveIfNewer (
 									apk,
 									symbolsPath,
-									assemblyDirectory + MonoAndroidHelper.MakeDiscreteAssembliesEntryName (Path.GetFileName (symbols)),
-									compressionMethod: UncompressedMethod
+									archiveSymbolsPath,
+									compressionMethod: GetCompressionMethod (archiveSymbolsPath)
 								);
 							}
 						}
@@ -605,7 +611,7 @@ void AddAssemblyConfigEntry (ZipArchiveEx apk, string assemblyPath, string confi
 				return;
 			}
 
-			CompressionMethod compressionMethod = UncompressedMethod;
+			CompressionMethod compressionMethod = GetCompressionMethod (inArchivePath);
 			if (apk.SkipExistingFile (configFile, inArchivePath, compressionMethod)) {
 				Log.LogDebugMessage ($"Skipping {configFile} as the archive file is up to date.");
 				return;

src/Xamarin.Android.Build.Tasks/Utilities/MonoAndroidHelper.Basic.cs

@@ -195,10 +195,10 @@ public static string MakeZipArchivePath (string part1, ICollection<string>? path
 	public static string MakeDiscreteAssembliesEntryName (string name, string? culture = null)
 	{
 		if (!String.IsNullOrEmpty (culture)) {
-			return $"%{culture}%{name}{MANGLED_ASSEMBLY_NAME_EXT}";
+			return $"_{culture}_{name}{MANGLED_ASSEMBLY_NAME_EXT}";
 		}
 
-		return $"#{name}{MANGLED_ASSEMBLY_NAME_EXT}";
+		return $"__{name}{MANGLED_ASSEMBLY_NAME_EXT}";
 	}
 
 	public static ulong GetMangledAssemblyNameSizeOverhead () => (ulong)MANGLED_ASSEMBLY_NAME_EXT.Length + 1;

src/monodroid/jni/embedded-assemblies.cc

@@ -1239,6 +1239,7 @@ EmbeddedAssemblies::register_from_apk (const char *apk_file, monodroid_should_re
 	return number_of_found_assemblies;
 }
 
+template<bool MangledNamesMode>
 force_inline bool
 EmbeddedAssemblies::maybe_register_assembly_from_filesystem (
 	[[maybe_unused]] monodroid_should_register should_register,
@@ -1255,17 +1256,21 @@ EmbeddedAssemblies::maybe_register_assembly_from_filesystem (
 		state.file_name = dir_entry->d_name;
 	};
 
-	// We're only interested in "mangled" file names, namely those starting with either the `#` or the `%` characters
-	if (dir_entry->d_name[0] == '#') {
-		assembly_count++;
-		copy_dentry_and_update_state (entry_name, state, dir_entry);
-		unmangle_name<UnmangleRegularAssembly> (entry_name);
-	} else if (dir_entry->d_name[0] == '%') {
-		assembly_count++;
-		copy_dentry_and_update_state (entry_name, state, dir_entry);
-		unmangle_name<UnmangleSatelliteAssembly> (entry_name);
+	if constexpr (MangledNamesMode) {
+		// We're only interested in "mangled" file names, namely those starting with either the `#` or the `%` characters
+		if (dir_entry->d_name[0] == '#') {
+			assembly_count++;
+			copy_dentry_and_update_state (entry_name, state, dir_entry);
+			unmangle_name<UnmangleRegularAssembly> (entry_name);
+		} else if (dir_entry->d_name[0] == '%') {
+			assembly_count++;
+			copy_dentry_and_update_state (entry_name, state, dir_entry);
+			unmangle_name<UnmangleSatelliteAssembly> (entry_name);
+		} else {
+			return false;
+		}
 	} else {
-		return false;
+		// TODO: check for .dll and .pdb extensions
 	}
 	state.data_offset = 0;
 
@@ -1313,12 +1318,10 @@ EmbeddedAssemblies::maybe_register_blob_from_filesystem (
 	return true;
 }
 
-size_t
-EmbeddedAssemblies::register_from_filesystem (monodroid_should_register should_register) noexcept
+force_inline size_t
+EmbeddedAssemblies::register_from_filesystem (const char *lib_dir_path,bool look_for_mangled_names, monodroid_should_register should_register) noexcept
 {
-	log_debug (LOG_ASSEMBLY, "Registering assemblies from the filesystem");
-
-	const char *lib_dir_path = androidSystem.app_lib_directories[0];
+	log_debug (LOG_ASSEMBLY, "Looking for assemblies in '%s'", lib_dir_path);
 	DIR *lib_dir = opendir (lib_dir_path); // TODO: put it in a scope guard at some point
 	if (lib_dir == nullptr) {
 		log_warn (LOG_ASSEMBLY, "Unable to open app library directory '%s': %s", lib_dir_path, std::strerror (errno));
@@ -1343,9 +1346,12 @@ EmbeddedAssemblies::register_from_filesystem (monodroid_should_register should_r
 	}
 
 	auto register_fn =
-		application_config.have_assembly_store ?
-		std::mem_fn (&EmbeddedAssemblies::maybe_register_blob_from_filesystem) :
-		std::mem_fn (&EmbeddedAssemblies::maybe_register_assembly_from_filesystem);
+		application_config.have_assembly_store ? std::mem_fn (&EmbeddedAssemblies::maybe_register_blob_from_filesystem) :
+		(look_for_mangled_names ?
+		 std::mem_fn (&EmbeddedAssemblies::maybe_register_assembly_from_filesystem<true>) :
+		 std::mem_fn (&EmbeddedAssemblies::maybe_register_assembly_from_filesystem<false>
+		)
+	);
 
 	size_t assembly_count = 0;
 	do {
@@ -1364,6 +1370,13 @@ EmbeddedAssemblies::register_from_filesystem (monodroid_should_register should_r
 			continue;
 		}
 
+#if defined (DEBUG)
+		if (!should_register (cur->d_name)) {
+			log_debug (LOG_ASSEMBLY, "In Debug build, '%s' should not be registered", cur->d_name);
+			continue;
+		}
+#endif // def DEBUG
+
 		// ...and we can handle the runtime config entry
 		if (!runtime_config_blob_found && std::strncmp (cur->d_name, SharedConstants::RUNTIME_CONFIG_BLOB_NAME, sizeof (SharedConstants::RUNTIME_CONFIG_BLOB_NAME) - 1) == 0) {
 			log_debug (LOG_ASSEMBLY, "Mapping runtime config blob from '%s'", cur->d_name);
@@ -1389,6 +1402,31 @@ EmbeddedAssemblies::register_from_filesystem (monodroid_should_register should_r
 	} while (true);
 	closedir (lib_dir);
 
+	return assembly_count;
+}
+
+size_t
+EmbeddedAssemblies::register_from_filesystem (monodroid_should_register should_register) noexcept
+{
+	log_debug (LOG_ASSEMBLY, "Registering assemblies from the filesystem");
+
+	constexpr bool LookForMangledNames = true;
+	size_t assembly_count = register_from_filesystem (
+		androidSystem.app_lib_directories[0],
+		LookForMangledNames,
+		should_register
+	);
+
+#if defined(DEBUG)
+	constexpr bool DoNotLookForMangledNames = false;
+
+	assembly_count += register_from_filesystem (
+		androidSystem.get_primary_override_dir (),
+		DoNotLookForMangledNames,
+		should_register
+	);
+#endif
+
 	log_debug (LOG_ASSEMBLY, "Found %zu assemblies on the filesystem", assembly_count);
 	return assembly_count;
 }

src/monodroid/jni/embedded-assemblies.hh

@@ -203,6 +203,9 @@ namespace xamarin::android::internal {
 		STATIC_IN_ANDROID_RELEASE MonoReflectionType* typemap_java_to_managed (hash_t hash, const MonoString *java_type_name) noexcept;
 		size_t register_from_apk (const char *apk_file, monodroid_should_register should_register) noexcept;
 		size_t register_from_filesystem (monodroid_should_register should_register) noexcept;
+		size_t register_from_filesystem (const char *dir, bool look_for_mangled_names, monodroid_should_register should_register) noexcept;
+
+		template<bool MangledNamesMode>
 		bool maybe_register_assembly_from_filesystem (monodroid_should_register should_register, size_t& assembly_count, const dirent* dir_entry, ZipEntryLoadState& state) noexcept;
 		bool maybe_register_blob_from_filesystem (monodroid_should_register should_register, size_t& assembly_count, const dirent* dir_entry, ZipEntryLoadState& state) noexcept;
 

src/monodroid/jni/monodroid-glue.cc

@@ -352,7 +352,7 @@ MonodroidRuntime::should_register_file ([[maybe_unused]] const char *filename)
 
 		if (exists) {
 			log_info (LOG_ASSEMBLY, "should not register '%s' as it exists in the override directory '%s'", filename, odir);
-			return !exists;
+			return false;
 		}
 	}
 #endif