[Hello-NativeAOTFromJNI] Add NativeAOT sample

build-tools/jnienv-gen/Generator.cs

@@ -758,7 +758,7 @@ abstract class TypeInfo
 			{ "void*",                      new BuiltinTypeInfo ("void*",                   "IntPtr") },
 			{ "const jchar*",               new StringTypeInfo ("const jchar*") },
 			{ "const char*",                new StringTypeInfo ("const char*") },
-			{ "const JNINativeMethod*",     new BuiltinTypeInfo ("const JNINativeMethod*",  "JniNativeMethodRegistration []") },
+			{ "const JNINativeMethod*",     new BuiltinTypeInfo ("const JNINativeMethod*",  "IntPtr") },
 			{ "jobjectRefType",             new BuiltinTypeInfo ("jobjectRefType",          "JniObjectReferenceType") },
 			{ "jfieldID",                   new InstanceFieldTypeInfo ("jfieldID") },
 			{ "jstaticfieldID",             new StaticFieldTypeInfo ("jstaticfieldID") },

samples/Hello-NativeAOTFromJNI/Hello-NativeAOTFromJNI.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>Hello_NativeAOTFromJNI</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <PublishAot>true</PublishAot>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <NativeLib>Shared</NativeLib>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Java.Interop\Java.Interop.csproj"
+        AdditionalProperties="Standalone=True"
+    />
+    <ProjectReference Include="..\..\src\Java.Runtime.Environment\Java.Runtime.Environment.csproj"
+        AdditionalProperties="Standalone=True"
+    />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="$(OutputPath)hello-from-java.jar" CopyToPublishDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <HelloNativeAOTFromJNIJar Include="$(MSBuildThisFileDirectory)java\**\*.java" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" $([MSBuild]::IsOSPlatform('linux')) Or $([MSBuild]::IsOSPlatform('FreeBSD')) Or $([MSBuild]::IsOSPlatform('Android')) ">
+    <CustomLinkerArg Include="-Wl,-soname,lib$(NativeBinary)$(NativeBinaryExt)" />
+  </ItemGroup>
+
+  <Import Project="Hello-NativeAOTFromJNI.targets" />
+</Project>

samples/Hello-NativeAOTFromJNI/Hello-NativeAOTFromJNI.targets

@@ -0,0 +1,53 @@
+<Project>
+
+  <Target Name="BuildNativeAOTFromJNIJar"
+      BeforeTargets="Build"
+      Inputs="@(HelloNativeAOTFromJNIJar)"
+      Outputs="$(OutputPath)hello-from-java.jar">
+    <MakeDir Directories="$(IntermediateOutputPath)h-classes" />
+    <ItemGroup>
+      <_Source Include="@(HelloNativeAOTFromJNIJar->Replace('%5c', '/'))" />
+    </ItemGroup>
+    <WriteLinesToFile
+        File="$(IntermediateOutputPath)_java_sources.txt"
+        Lines="@(_Source)"
+        Overwrite="True"
+    />
+    <ItemGroup>
+      <_JavacOpt Include="$(_JavacSourceOptions)" />
+      <_JavacOpt Include="-d &quot;$(IntermediateOutputPath)h-classes&quot; " />
+      <_JavacOpt Include="-classpath &quot;$(OutputPath)java-interop.jar&quot; " />
+      <_JavacOpt Include="&quot;@$(IntermediateOutputPath)_java_sources.txt&quot;" />
+      <_JavacOpt Include="-h &quot;$(IntermediateOutputPath)h-classes&quot; " />
+    </ItemGroup>
+    <Exec Command="&quot;$(JavaCPath)&quot; @(_JavacOpt, ' ')" />
+    <Delete Files="$(IntermediateOutputPath)_java_sources.txt" />
+    <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(OutputPath)hello-from-java.jar&quot; -C &quot;$(IntermediateOutputPath)h-classes&quot; ." />
+  </Target>
+
+  <Target Name="_NativeLibRequiresLibPrefix"
+      AfterTargets="Publish">
+    <Copy
+        Condition=" '$(OS)' != 'Windows_NT' "
+        SourceFiles="$(PublishDir)$(AssemblyName).dylib"
+        DestinationFiles="$(PublishDir)lib$(AssemblyName).dylib"
+    />
+    <Copy SourceFiles="$(OutputPath)hello-from-java.jar" DestinationFolder="$(PublishDir)" />
+  </Target>
+
+  <Target Name="RunJavaSample">
+    <ItemGroup>
+      <_Classpath Include="hello-from-java.jar" />
+      <_Classpath Include="java-interop.jar" />
+    </ItemGroup>
+    <PropertyGroup>
+      <_CPSep Condition=" '$(OS)' == 'Windows_NT' ">;</_CPSep>
+      <_CPSep Condition=" '$(_CPSep)' == '' ">:</_CPSep>
+      <_CP>@(_Classpath, '$(_CPSep)')</_CP>
+    </PropertyGroup>
+    <Exec
+        Command="&quot;$(JavaPath)&quot; -classpath &quot;$(_CP)&quot; com/microsoft/hello_from_jni/App"
+        WorkingDirectory="$(PublishDir)"
+    />
+  </Target>
+</Project>

samples/Hello-NativeAOTFromJNI/JNIEnvInit.cs

@@ -0,0 +1,44 @@
+using System.Runtime.InteropServices;
+
+using Java.Interop;
+
+namespace Hello_NativeAOTFromJNI;
+
+static class JNIEnvInit
+{
+	static JniRuntime? runtime;
+
+	[UnmanagedCallersOnly (EntryPoint="JNI_OnLoad")]
+	static int JNI_OnLoad (IntPtr vm, IntPtr reserved)
+	{
+		try {
+			var options = new JreRuntimeOptions {
+				InvocationPointer = vm,
+			};
+			runtime = options.CreateJreVM ();
+			return (int) runtime.JniVersion;
+		}
+		catch (Exception e) {
+			Console.Error.WriteLine ($"JNI_OnLoad: error: {e}");
+			return 0;
+		}
+	}
+
+	[UnmanagedCallersOnly (EntryPoint="JNI_OnUnload")]
+	static void JNI_Onload (IntPtr vm, IntPtr reserved)
+	{
+		runtime?.Dispose ();
+	}
+
+	// symbol name from `$(IntermediateOutputPath)/h-classes/com_microsoft_hello_from_jni_NativeAOTInit.h`
+	[UnmanagedCallersOnly (EntryPoint="Java_com_microsoft_hello_1from_1jni_NativeAOTInit_sayHello")]
+	static IntPtr sayHello (IntPtr jnienv, IntPtr klass)
+	{
+		var s = $"Hello from .NET NativeAOT!";
+		Console.WriteLine (s);
+		var h = JniEnvironment.Strings.NewString (s);
+		var r = JniEnvironment.References.NewReturnToJniRef (h);
+		JniObjectReference.Dispose (ref h);
+		return r;
+	}
+}

samples/Hello-NativeAOTFromJNI/README.md

@@ -0,0 +1,67 @@
+# Hello From JNI
+
+[JNI][0] supports *two* modes of operation:
+
+ 1. Native code creates the JVM, e.g. via [`JNI_CreateJavaVM()`][1], or
+ 2. The JVM already exists, and calls [`JNI_OnLoad()`][2] when loading a native library.
+
+Java.Interop samples and unit tests rely on the first approach.
+
+.NET Android / neé Xamarin.Android is the second approach.
+
+Bring an example of the latter into a Java.Interop sample, using [NativeAOT][3].
+
+## Building
+
+Building a native library with NativeAOT requires a Release configuration build.
+For in-repo use, that means that xamarin/Java.Interop itself needs to be built in
+Release configuration:
+
+```sh
+% dotnet build -c Release -t:Prepare
+% dotnet build -c Release
+```
+
+Once Java.Interop itself is built, you can build the sample:
+
+```sh
+% dotnet build -c Release
+% dotnet publish -r osx-x64
+```
+
+The resulting native library contains the desired symbols:
+
+```sh
+% nm bin/Release/osx-x64/publish/Hello-NativeAOTFromJNI.dylib | grep ' S ' 
+00000000000cb710 S _JNI_OnLoad
+00000000000cb820 S _JNI_OnUnload
+00000000000cb840 S _Java_com_microsoft_hello_1from_1jni_NativeAOTInit_sayHello
+```
+
+Use the `RunJavaSample` target to run Java, which will run
+`System.loadLibrary("Hello-NativeAOTFromJNI")`, which will cause the
+NativeAOT-generated `libHello-NativeAOTFromJNI.dylib` to be run:
+
+```sh
+% dotnet build -c Release -r osx-x64 -t:RunJavaSample  -v m --nologo --no-restore
+  Hello from Java!
+  Hello from .NET NativeAOT!
+
+Build succeeded.
+    0 Warning(s)
+    0 Error(s)
+
+Time Elapsed 00:00:00.83
+
+% (cd bin/Release/osx-x64/publish ; java -cp hello-from-java.jar:java-interop.jar com/microsoft/hello_from_jni/App)
+Hello from Java!
+Hello from .NET NativeAOT!
+```
+
+Note the use of `(cd …; java …)` so that `libHello-NativeAOTFromJNI.dylib` is
+in the current working directory, so that it can be found.
+
+[0]: https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/jniTOC.html
+[1]: https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/invocation.html#creating_the_vm
+[2]: https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/invocation.html#JNJI_OnLoad
+[3]: https://github.com/dotnet/samples/blob/main/core/nativeaot/NativeLibrary/README.md

samples/Hello-NativeAOTFromJNI/java/com/microsoft/hello_from_jni/App.java

@@ -0,0 +1,10 @@
+package com.microsoft.hello_from_jni;
+
+class App {
+
+    public static void main(String[] args) {
+        System.out.println("Hello from Java!");
+        String s = NativeAOTInit.sayHello();
+        System.out.println("String returned to Java: " + s);
+    }
+}

samples/Hello-NativeAOTFromJNI/java/com/microsoft/hello_from_jni/NativeAOTInit.java

@@ -0,0 +1,9 @@
+package com.microsoft.hello_from_jni;
+
+class NativeAOTInit {
+    static {
+        System.loadLibrary("Hello-NativeAOTFromJNI");
+    }
+
+    public static native String sayHello();
+}

src/Java.Interop/Java.Interop.csproj

@@ -26,9 +26,10 @@
     <OutputPath>$(ToolOutputFullPath)</OutputPath>
     <DocumentationFile>$(ToolOutputFullPath)Java.Interop.xml</DocumentationFile>
     <JNIEnvGenPath>$(BuildToolOutputFullPath)</JNIEnvGenPath>
-    <LangVersion Condition=" '$(JIBuildingForNetCoreApp)' == 'True' ">9.0</LangVersion>
+    <LangVersion Condition=" '$(JIBuildingForNetCoreApp)' == 'True' ">11.0</LangVersion>
     <LangVersion Condition=" '$(LangVersion)' == '' ">8.0</LangVersion>
     <Version>$(JICoreLibVersion)</Version>
+    <Standalone Condition=" '$(Standalone)' == '' ">true</Standalone>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Standalone)' == 'True' ">
     <DefineConstants Condition=" '$(JIBuildingForNetCoreApp)' == 'True' ">FEATURE_JNIENVIRONMENT_JI_FUNCTION_POINTERS;$(DefineConstants)</DefineConstants>

src/Java.Interop/Java.Interop/JniEnvironment.Types.cs

@@ -250,6 +250,9 @@ public static void RegisterNatives (JniObjectReference type, JniNativeMethodRegi
 					throw new ArgumentOutOfRangeException (nameof (numMethods), numMethods,
 							$"`numMethods` must be between 0 and `methods.Length` ({methods?.Length ?? 0})!");
 				}
+				if (methods == null || numMethods == 0) {
+					return;
+				}
 #if DEBUG && NETCOREAPP
 				for (int i = 0; methods != null && i < numMethods; ++i) {
 					var m   = methods [i];
@@ -262,8 +265,42 @@ public static void RegisterNatives (JniObjectReference type, JniNativeMethodRegi
 				}
 #endif  // DEBUG && NETCOREAPP
 
-				int r   = _RegisterNatives (type, methods, numMethods);
+				Span<JniBlittableNativeMethodRegistration> blittableMethods
+					= stackalloc JniBlittableNativeMethodRegistration [numMethods];
+				Span<IntPtr> freeStrings
+					= stackalloc IntPtr [numMethods * 2];
+				try {
+					for (int i = 0; i < numMethods; ++i) {
+						var name    = methods [i].Name == null ? IntPtr.Zero : Marshal.StringToCoTaskMemUTF8 (methods [i].Name);
+						var sig     = methods [i].Signature == null ? IntPtr.Zero : Marshal.StringToCoTaskMemUTF8 (methods [i].Signature);
+
+						freeStrings [(i*2)+0] = name;
+						freeStrings [(i*2)+1] = sig;
+
+						blittableMethods [i] = new JniBlittableNativeMethodRegistration (
+								name,
+								sig,
+								Marshal.GetFunctionPointerForDelegate (methods [i].Marshaler)
+						);
+					}
+					RegisterNatives (type, blittableMethods);
+				}
+				finally {
+					for (int i = 0; i < freeStrings.Length; ++i) {
+						Marshal.ZeroFreeCoTaskMemUTF8 (freeStrings [i]);
+					}
+				}
+			}
 
+			public static unsafe void RegisterNatives (JniObjectReference type, ReadOnlySpan<JniBlittableNativeMethodRegistration> methods)
+			{
+				if (methods.Length == 0) {
+					return;
+				}
+				int r;
+				fixed (JniBlittableNativeMethodRegistration* pMethods = methods) {
+					r = _RegisterNatives (type, (IntPtr) pMethods, methods.Length);
+				}
 				if (r != 0) {
 					throw new InvalidOperationException (
 							string.Format ("Could not register native methods for class '{0}'; JNIEnv::RegisterNatives() returned {1}.", GetJniTypeNameFromClass (type), r));

src/Java.Interop/Java.Interop/JniNativeMethodRegistration.cs

@@ -20,4 +20,70 @@ public JniNativeMethodRegistration (string name, string signature, Delegate mars
 			Marshaler   = marshaler ?? throw new ArgumentNullException (nameof (marshaler));
 		}
 	}
+
+	public struct JniBlittableNativeMethodRegistration : IEquatable<JniBlittableNativeMethodRegistration> {
+
+		IntPtr name, signature, marshaler;
+
+		public JniBlittableNativeMethodRegistration (IntPtr name, IntPtr signature, IntPtr marshaler)
+		{
+			if (name == IntPtr.Zero)
+				throw new ArgumentNullException (nameof (name));
+			if (signature == IntPtr.Zero)
+				throw new ArgumentNullException (nameof (signature));
+			if (marshaler == IntPtr.Zero)
+				throw new ArgumentNullException (nameof (marshaler));
+
+			this.name       = name;
+			this.signature  = signature;
+			this.marshaler  = marshaler;
+		}
+
+		public JniBlittableNativeMethodRegistration (ReadOnlySpan<byte> name, ReadOnlySpan<byte> signature, IntPtr marshaler)
+		{
+			if (name.Length == 0)
+				throw new ArgumentException ("must not be empty", nameof (name));
+			if (signature.Length == 0)
+				throw new ArgumentException ("must not be empty", nameof (signature));
+			if (marshaler == IntPtr.Zero)
+				throw new ArgumentNullException (nameof (marshaler));
+
+			this.name       = FromReadOnlySpan (name);
+			this.signature  = FromReadOnlySpan (signature);
+			this.marshaler  = marshaler;
+		}
+
+		// Dodgy AF, but as the C# compiler guarantees no allocations for u8 strings,
+		// the "address" of `value` will never move, so this is "fine"…
+		// *so long as* it's *only* used for "string"u8 values.
+		// https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-11.0/utf8-string-literals#detailed-design
+		// > Since the literals would be allocated as global constants, the lifetime of the
+		// > resulting ReadOnlySpan<byte> would not prevent it from being returned or passed around to elsewhere. 
+		static unsafe IntPtr FromReadOnlySpan (ReadOnlySpan<byte> value)
+		{
+			fixed (byte* p = value)
+				return (IntPtr) p;
+		}
+
+		public override bool Equals (object? obj)
+		{
+			if (obj is JniBlittableNativeMethodRegistration other) {
+				return Equals (other);
+			}
+			return false;
+		}
+
+		public override int GetHashCode () =>
+			HashCode.Combine (name, signature, marshaler);
+
+		public bool Equals (JniBlittableNativeMethodRegistration other) =>
+			name == other.name &&
+			signature == other.signature &&
+			marshaler == other.marshaler;
+
+		public static bool operator == (JniBlittableNativeMethodRegistration lhs, JniBlittableNativeMethodRegistration rhs) =>
+			lhs.Equals (rhs);
+		public static bool operator != (JniBlittableNativeMethodRegistration lhs, JniBlittableNativeMethodRegistration rhs) =>
+			!lhs.Equals (rhs);
+	}
 }

src/Java.Interop/Java.Interop/JniType.cs

@@ -168,6 +168,13 @@ public void RegisterNativeMethods (params JniNativeMethodRegistration[] methods)
 			RegisterWithRuntime ();
 		}
 
+		public void RegisterNativeMethods (ReadOnlySpan<JniBlittableNativeMethodRegistration> methods)
+		{
+			AssertValid ();
+			JniEnvironment.Types.RegisterNatives (PeerReference, methods);
+			RegisterWithRuntime ();
+		}
+
 		public void UnregisterNativeMethods ()
 		{
 			AssertValid ();