Auto-generate crc64 package name when package is empty in XmlImporter

src/Java.Interop.Tools.JavaCallableWrappers/Java.Interop.Tools.JavaCallableWrappers.Adapters/XmlImporter.cs

@@ -6,6 +6,7 @@
 using System.Xml.Linq;
 using Java.Interop.Tools.JavaCallableWrappers.CallableWrapperMembers;
 using Java.Interop.Tools.JavaCallableWrappers.Extensions;
+using Java.Interop.Tools.TypeNameMappings;
 
 namespace Java.Interop.Tools.JavaCallableWrappers.Adapters;
 
@@ -52,6 +53,10 @@ public static CallableWrapperType ImportType (XElement xml)
 		var package = xml.GetAttributeOrDefault ("package", (string?) "");
 		var partial_assembly_qualified_name = xml.GetRequiredAttribute ("partial_assembly_qualified_name");
 
+		// If package is empty, generate a crc64 package name from the assembly qualified name
+		if (string.IsNullOrEmpty (package))
+			package = GeneratePackageFromAssemblyQualifiedName (partial_assembly_qualified_name);
+
 		var type = new CallableWrapperType (name, package ?? "", partial_assembly_qualified_name) {
 			ApplicationJavaClass = xml.GetAttributeOrDefault ("application_java_class", (string?) null),
 			ExtendsType = xml.GetAttributeOrDefault ("extends_type", (string?) null),
@@ -198,4 +203,35 @@ static CallableWrapperField ImportField (XElement xml)
 
 		return field;
 	}
+
+	/// <summary>
+	/// Generates a package name from a partial assembly qualified name.
+	/// This is used when the package attribute is missing or empty in the XML.
+	/// </summary>
+	/// <param name="partialAssemblyQualifiedName">The partial assembly qualified name in format "Namespace.TypeName, AssemblyName"</param>
+	/// <returns>A package name based on the current <see cref="JavaNativeTypeManager.PackageNamingPolicy"/></returns>
+	static string GeneratePackageFromAssemblyQualifiedName (string partialAssemblyQualifiedName)
+	{
+		// Format: "Namespace.TypeName, AssemblyName" or "Namespace.TypeName+NestedType, AssemblyName"
+		var commaIndex = partialAssemblyQualifiedName.IndexOf (',');
+		if (commaIndex < 0)
+			return "";
+
+		var fullTypeName = partialAssemblyQualifiedName.Substring (0, commaIndex).Trim ();
+		var assemblyName = partialAssemblyQualifiedName.Substring (commaIndex + 1).Trim ();
+
+		// Extract namespace from full type name
+		// Handle nested types by using '+' as separator
+		var plusIndex = fullTypeName.IndexOf ('+');
+		var typeNameWithoutNested = plusIndex >= 0 ? fullTypeName.Substring (0, plusIndex) : fullTypeName;
+
+		var lastDotIndex = typeNameWithoutNested.LastIndexOf ('.');
+		var ns = lastDotIndex >= 0 ? typeNameWithoutNested.Substring (0, lastDotIndex) : "";
+
+		// If no namespace, return empty (will use default package)
+		if (string.IsNullOrEmpty (ns))
+			return "";
+
+		return JavaNativeTypeManager.GetPackageName (ns, assemblyName);
+	}
 }

src/Java.Interop.Tools.TypeNameMappings/Java.Interop.Tools.TypeNameMappings/JavaNativeTypeManager.cs

@@ -221,13 +221,24 @@ public static string GetPackageName (Type type)
 			string assemblyName = GetAssemblyName (type.Assembly);
 			if (IsPackageNamePreservedForAssembly (assemblyName))
 				return type.Namespace!.ToLowerInvariant ();
+			return GetPackageName (type.Namespace ?? "", assemblyName);
+		}
+
+		/// <summary>
+		/// Generates a package name from a namespace and assembly name.
+		/// </summary>
+		/// <param name="ns">The namespace of the type.</param>
+		/// <param name="assemblyName">The assembly name.</param>
+		/// <returns>A package name based on the current <see cref="PackageNamingPolicy"/>.</returns>
+		public static string GetPackageName (string ns, string assemblyName)
+		{
 			switch (PackageNamingPolicy) {
 			case PackageNamingPolicy.Lowercase:
-				return type.Namespace!.ToLowerInvariant ();
+				return ns.ToLowerInvariant ();
 			case PackageNamingPolicy.LowercaseWithAssemblyName:
-				return "assembly_" + (assemblyName.Replace ('.', '_') + "." + type.Namespace).ToLowerInvariant ();
+				return "assembly_" + (assemblyName.Replace ('.', '_') + "." + ns).ToLowerInvariant ();
 			case PackageNamingPolicy.LowercaseCrc64:
-				return CRC_PREFIX + ToCrc64 (type.Namespace + ":" + assemblyName);
+				return CRC_PREFIX + ToCrc64 (ns + ":" + assemblyName);
 			default:
 					throw new NotSupportedException ($"PackageNamingPolicy.{PackageNamingPolicy} is no longer supported.");
 			}
@@ -672,16 +683,7 @@ public static string GetPackageName (TypeDefinition type, IMetadataResolver reso
 		{
 			if (IsPackageNamePreservedForAssembly (type.GetPartialAssemblyName (resolver)))
 				return type.Namespace.ToLowerInvariant ();
-			switch (PackageNamingPolicy) {
-			case PackageNamingPolicy.Lowercase:
-				return type.Namespace.ToLowerInvariant ();
-			case PackageNamingPolicy.LowercaseWithAssemblyName:
-				return "assembly_" + (type.GetPartialAssemblyName (resolver).Replace ('.', '_') + "." + type.Namespace).ToLowerInvariant ();
-			case PackageNamingPolicy.LowercaseCrc64:
-				return CRC_PREFIX + ToCrc64 (type.Namespace + ":" + type.GetPartialAssemblyName (resolver));
-			default:
-					throw new NotSupportedException ($"PackageNamingPolicy.{PackageNamingPolicy} is no longer supported.");
-			}
+			return GetPackageName (type.Namespace, type.GetPartialAssemblyName (resolver));
 		}
 #endif
 

tests/Java.Interop.Tools.JavaCallableWrappers-Tests/Java.Interop.Tools.JavaCallableWrappers/XmlImporterTests.cs

@@ -0,0 +1,144 @@
+using System.IO;
+using System.Xml.Linq;
+using Java.Interop.Tools.JavaCallableWrappers.Adapters;
+using Java.Interop.Tools.TypeNameMappings;
+using NUnit.Framework;
+
+namespace Java.Interop.Tools.JavaCallableWrappersTests
+{
+	[TestFixture]
+	public class XmlImporterTests
+	{
+		PackageNamingPolicy existingValue;
+
+		[SetUp]
+		public void SetUp ()
+		{
+			existingValue = JavaNativeTypeManager.PackageNamingPolicy;
+			JavaNativeTypeManager.PackageNamingPolicy = PackageNamingPolicy.LowercaseCrc64;
+		}
+
+		[TearDown]
+		public void TearDown ()
+		{
+			JavaNativeTypeManager.PackageNamingPolicy = existingValue;
+		}
+
+		[Test]
+		public void ImportType_EmptyPackage_GeneratesCrc64Package ()
+		{
+			// Simulate the case where [Register("CustomView")] is used without a package prefix
+			// The XML has an empty package attribute, and we expect XmlImporter to generate a crc64 package
+			var xml = XElement.Parse (@"
+				<type name=""CustomView"" 
+				      package="""" 
+				      partial_assembly_qualified_name=""MyApp.Views.CustomView, MyApp.Android"" 
+				      extends_type=""android.view.View"">
+					<constructors />
+					<methods />
+				</type>");
+
+			var type = XmlImporter.ImportType (xml);
+
+			// The generated package should be "crc64" + crc64hash of "MyApp.Views:MyApp.Android"
+			Assert.AreEqual ("crc64b8e52a012da2d805", type.Package);
+			Assert.AreEqual ("CustomView", type.Name);
+		}
+
+		[Test]
+		public void ImportType_EmptyPackage_NestedType_GeneratesCrc64Package ()
+		{
+			// Simulate the case with a nested type
+			var xml = XElement.Parse (@"
+				<type name=""InnerView"" 
+				      package="""" 
+				      partial_assembly_qualified_name=""MyApp.Views.OuterView+InnerView, MyApp.Android"" 
+				      extends_type=""android.view.View"">
+					<constructors />
+					<methods />
+				</type>");
+
+			var type = XmlImporter.ImportType (xml);
+
+			// The generated package should be based on "MyApp.Views:MyApp.Android" (ignoring nested type part)
+			Assert.AreEqual ("crc64b8e52a012da2d805", type.Package);
+			Assert.AreEqual ("InnerView", type.Name);
+		}
+
+		[Test]
+		public void ImportType_MissingPackageAttribute_GeneratesCrc64Package ()
+		{
+			// Simulate the case where the package attribute is completely missing
+			var xml = XElement.Parse (@"
+				<type name=""CustomView"" 
+				      partial_assembly_qualified_name=""MyApp.Views.CustomView, MyApp.Android"" 
+				      extends_type=""android.view.View"">
+					<constructors />
+					<methods />
+				</type>");
+
+			var type = XmlImporter.ImportType (xml);
+
+			// The generated package should be "crc64" + crc64hash of "MyApp.Views:MyApp.Android"
+			Assert.AreEqual ("crc64b8e52a012da2d805", type.Package);
+		}
+
+		[Test]
+		public void ImportType_WithPackage_UsesProvidedPackage ()
+		{
+			// Ensure that when a package is provided, it is used directly
+			var xml = XElement.Parse (@"
+				<type name=""CustomView"" 
+				      package=""my.custom.package"" 
+				      partial_assembly_qualified_name=""MyApp.Views.CustomView, MyApp.Android"" 
+				      extends_type=""android.view.View"">
+					<constructors />
+					<methods />
+				</type>");
+
+			var type = XmlImporter.ImportType (xml);
+
+			Assert.AreEqual ("my.custom.package", type.Package);
+		}
+
+		[Test]
+		public void ImportType_NoNamespace_ReturnsEmptyPackage ()
+		{
+			// When there's no namespace in the type name, we can't generate a package
+			var xml = XElement.Parse (@"
+				<type name=""CustomView"" 
+				      package="""" 
+				      partial_assembly_qualified_name=""CustomView, MyApp.Android"" 
+				      extends_type=""android.view.View"">
+					<constructors />
+					<methods />
+				</type>");
+
+			var type = XmlImporter.ImportType (xml);
+
+			// Without a namespace, we can't generate a crc64 package, so it should remain empty
+			Assert.AreEqual ("", type.Package);
+		}
+
+		[Test]
+		public void ImportType_XamarinAndroidToolsTests_MatchesExpectedCrc64 ()
+		{
+			// This test verifies the crc64 generation matches what JavaNativeTypeManager would generate
+			// Based on the test data in JavaCallableWrapperGeneratorTests, namespace "Xamarin.Android.ToolsTests"
+			// with assembly "Java.Interop.Tools.JavaCallableWrappers-Tests" should produce crc64197ae30a36756915
+			var xml = XElement.Parse (@"
+				<type name=""ExportsMembers"" 
+				      package="""" 
+				      partial_assembly_qualified_name=""Xamarin.Android.ToolsTests.ExportsMembers, Java.Interop.Tools.JavaCallableWrappers-Tests"" 
+				      extends_type=""java.lang.Object"">
+					<constructors />
+					<methods />
+				</type>");
+
+			var type = XmlImporter.ImportType (xml);
+
+			// This should match the expected crc64 from JavaCallableWrapperGeneratorTests
+			Assert.AreEqual ("crc64197ae30a36756915", type.Package);
+		}
+	}
+}