Merge main into xcode14. (#15950)

msbuild/Directory.Build.props

@@ -1,6 +1,6 @@
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 	<PropertyGroup>
-		<MessagingVersion>1.7.9</MessagingVersion>
+		<MessagingVersion>1.7.14</MessagingVersion>
 		<HotRestartVersion>1.0.93</HotRestartVersion>
 	</PropertyGroup>
 </Project>

msbuild/Xamarin.MacDev.Tasks/Tasks/DetectSigningIdentityTaskBase.cs

@@ -104,6 +104,12 @@ protected string ApplicationIdentifierKey {
 
 		public string BundleIdentifier { get; set; }
 
+		public string CodesignProvision { get; set; }
+
+		public string CodesignEntitlements { get; set; }
+
+		public string CodesignRequireProvisioningProfile { get; set; }
+
 		public string Keychain { get; set; }
 
 		public string SigningKey { get; set; }
@@ -117,8 +123,6 @@ protected string ApplicationIdentifierKey {
 
 		public bool RequireCodeSigning { get; set; }
 
-		public bool RequireProvisioningProfile { get; set; }
-
 		#endregion
 
 		#region Outputs
@@ -141,6 +145,59 @@ protected string ApplicationIdentifierKey {
 
 		#endregion
 
+		bool? requireProvisioningProfile;
+		public bool RequireProvisioningProfile {
+			get {
+				// RequireProvisioningProfile:
+				// * iOS, tvOS, watchOS: required if building for device or if a custom (.NET: non-empty) entitlement file is used
+				// * macOS, Mac Catalyst: requirerd if a provisioning profile is specified
+				// * Default logic is overridable by setting the "CodesignRequireProvisioningProfile=true|false" property
+
+				if (!requireProvisioningProfile.HasValue) {
+					if (string.IsNullOrEmpty (CodesignRequireProvisioningProfile)) {
+						switch (Platform) {
+						case ApplePlatform.iOS:
+						case ApplePlatform.TVOS:
+						case ApplePlatform.WatchOS:
+							requireProvisioningProfile = !SdkIsSimulator || HasEntitlements;
+							break;
+						case ApplePlatform.MacCatalyst:
+						case ApplePlatform.MacOSX:
+							requireProvisioningProfile = !string.IsNullOrEmpty (CodesignProvision);
+							break;
+						default:
+							throw new InvalidOperationException (string.Format (MSBStrings.InvalidPlatform, Platform));
+						}
+					} else {
+						requireProvisioningProfile = string.Equals (CodesignRequireProvisioningProfile, "true", StringComparison.OrdinalIgnoreCase);
+					}
+				}
+				return requireProvisioningProfile.Value;
+			}
+		}
+
+		bool? hasEntitlements;
+		bool HasEntitlements {
+			get {
+				if (!hasEntitlements.HasValue) {
+					if (string.IsNullOrEmpty (CodesignEntitlements)) {
+						// If no CodesignEntitlements was specified, we don't have any entitlements
+						hasEntitlements = false;
+					} else {
+						if (IsDotNet) {
+							// .NET: Check the file to see if there are any entitlements inside
+							var entitlements = PDictionary.FromFile (CodesignEntitlements);
+							hasEntitlements = entitlements.Count > 0;
+						} else {
+							// Legacy Xamarin: to preserve backwards compat, consider the presence of a file enough to say we have entitlements.
+							hasEntitlements = true;
+						}
+					}
+				}
+				return hasEntitlements.Value;
+			}
+		}
+
 		class CodeSignIdentity
 		{
 			public X509Certificate2 SigningKey { get; set; }

msbuild/Xamarin.Shared/Xamarin.Shared.props

@@ -136,16 +136,6 @@ Copyright (C) 2020 Microsoft. All rights reserved.
 		-->
 		<CodesignEntitlements Condition="'$(UsingAppleNETSdk)' == 'true' And '$(CodesignEntitlements)' == '' And Exists('Entitlements.plist') And '$(EnableDefaultCodesignEntitlements)' != 'false'">Entitlements.plist</CodesignEntitlements>
 
-		<!-- _RequireProvisioningProfile -->
-		<!-- Default: false -->
-		<!-- macOS: true if a provisioning profile is used -->
-		<!-- iOS/tvOS/watchOS: true if building for device or if a custom entitlements file is used -->
-		<!-- Mac Catalyst: true if a provisioning profile is used -->
-		<_RequireProvisioningProfile Condition="'$(_RequireProvisioningProfile)' == '' And '$(_PlatformName)' == 'macOS' And '$(CodesignProvision)' != ''">true</_RequireProvisioningProfile>
-		<_RequireProvisioningProfile Condition="'$(_RequireProvisioningProfile)' == '' And ('$(_PlatformName)' == 'iOS' Or '$(_PlatformName)' == 'tvOS' Or '$(_PlatformName)' == 'watchOS') And ('$(ComputedPlatform)' == 'iPhone' Or '$(CodesignEntitlements)' != '')">true</_RequireProvisioningProfile>
-		<_RequireProvisioningProfile Condition="'$(_RequireProvisioningProfile)' == '' And '$(_PlatformName)' == 'MacCatalyst' And '$(CodesignProvision)' != ''">true</_RequireProvisioningProfile>
-		<_RequireProvisioningProfile Condition="'$(_RequireProvisioningProfile)' == ''">false</_RequireProvisioningProfile>
-
 		<!-- If we should automatically try to detect the app manifest (Info.plist) from any None, BundleResource or Content items -->
 		<!-- It might be desirable to turn off the automatic detection if the current logic detects Info.plist that aren't the app manifest -->
 		<!-- One example would be when including native frameworks in the app bundle - frameworks have an Info.plist that might be picked up -->

msbuild/Xamarin.Shared/Xamarin.Shared.targets

@@ -1698,12 +1698,14 @@ Copyright (C) 2018 Microsoft. All rights reserved.
 	<Target Name="_DetectSigningIdentity" Condition="'$(_CanOutputAppBundle)' == 'true'" DependsOnTargets="$(_DetectSigningIdentityDependsOn)">
 		<DetectSigningIdentity
 			SessionId="$(BuildSessionId)"
+			CodesignProvision="$(CodesignProvision)"
+			CodesignEntitlements="$(CodesignEntitlements)"
+			CodesignRequireProvisioningProfile="$(CodesignRequireProvisioningProfile)"
 			Condition="'$(IsMacEnabled)' == 'true'"
 			AppBundleName="$(_AppBundleName)"
 			BundleIdentifier="$(_BundleIdentifier)"
 			Keychain="$(CodesignKeychain)"
 			RequireCodeSigning="$(_RequireCodeSigning)"
-			RequireProvisioningProfile="$(_RequireProvisioningProfile)"
 			SdkIsSimulator="$(_SdkIsSimulator)"
 			SdkPlatform="$(_SdkPlatform)"
 			ProvisioningProfile="$(CodesignProvision)"

src/CoreGraphics/CGDataProvider.cs

@@ -144,29 +144,48 @@ public CGDataProvider (NSData data)
 		{
 		}
 
+#if NET
+		[DllImport (Constants.CoreGraphicsLibrary)]
+		extern static unsafe IntPtr CGDataProviderCreateWithData (/* void* */ IntPtr info, /* const void* */ IntPtr data, /* size_t */ nint size, /* CGDataProviderReleaseDataCallback */ delegate* unmanaged<IntPtr, IntPtr, nint, void> releaseData);
+#else
 		[DllImport (Constants.CoreGraphicsLibrary)]
 		extern static IntPtr CGDataProviderCreateWithData (/* void* */ IntPtr info, /* const void* */ IntPtr data, /* size_t */ nint size, /* CGDataProviderReleaseDataCallback */ CGDataProviderReleaseDataCallback releaseData);
+#endif
 
+#if !NET
 		delegate void CGDataProviderReleaseDataCallback (IntPtr info, IntPtr data, nint size);
 		static CGDataProviderReleaseDataCallback release_gchandle_callback = ReleaseGCHandle;
 		static CGDataProviderReleaseDataCallback release_buffer_callback = ReleaseBuffer;
 		static CGDataProviderReleaseDataCallback release_func_callback = ReleaseFunc;
+#endif
 
+#if NET
+		[UnmanagedCallersOnly]
+#else
 		[MonoPInvokeCallback (typeof (CGDataProviderReleaseDataCallback))]
+#endif
 		private static void ReleaseGCHandle (IntPtr info, IntPtr data, nint size)
 		{
 			var gch = GCHandle.FromIntPtr (info);
 			gch.Free ();
 		}
 
+#if NET
+		[UnmanagedCallersOnly]
+#else
 		[MonoPInvokeCallback (typeof (CGDataProviderReleaseDataCallback))]
+#endif
 		private static void ReleaseBuffer (IntPtr info, IntPtr data, nint size)
 		{
 			if (data != IntPtr.Zero)
 				Marshal.FreeHGlobal (data);
 		}
 
+#if NET
+		[UnmanagedCallersOnly]
+#else
 		[MonoPInvokeCallback (typeof (CGDataProviderReleaseDataCallback))]
+#endif
 		private static void ReleaseFunc (IntPtr info, IntPtr data, nint size)
 		{
 			var gch = GCHandle.FromIntPtr (info);
@@ -188,7 +207,13 @@ static IntPtr Create (IntPtr memoryBlock, int size, bool ownBuffer)
 		{
 			if (!ownBuffer)
 				memoryBlock = Runtime.CloneMemory (memoryBlock, size);
+#if NET
+			unsafe {
+				return CGDataProviderCreateWithData (IntPtr.Zero, memoryBlock, size, &ReleaseBuffer);
+			}
+#else
 			return CGDataProviderCreateWithData (IntPtr.Zero, memoryBlock, size, release_buffer_callback);
+#endif
 		}
 
 		public CGDataProvider (IntPtr memoryBlock, int size, bool ownBuffer)
@@ -202,7 +227,13 @@ static IntPtr Create (IntPtr memoryBlock, int size, Action<IntPtr> releaseMemory
 				ObjCRuntime.ThrowHelper.ThrowArgumentNullException (nameof (releaseMemoryBlockCallback));
 
 			var gch = GCHandle.Alloc (releaseMemoryBlockCallback);
+#if NET
+			unsafe {
+				return CGDataProviderCreateWithData (GCHandle.ToIntPtr (gch), memoryBlock, size, &ReleaseFunc);
+			}
+#else
 			return CGDataProviderCreateWithData (GCHandle.ToIntPtr (gch), memoryBlock, size, release_func_callback);
+#endif
 		}
 
 		public CGDataProvider (IntPtr memoryBlock, int size, Action<IntPtr> releaseMemoryBlockCallback)
@@ -221,7 +252,13 @@ static IntPtr Create (byte [] buffer, int offset, int count)
 
 			var gch = GCHandle.Alloc (buffer, GCHandleType.Pinned); // This requires a pinned GCHandle, because unsafe code is scoped to the current block, and the address of the byte array will be used after this function returns.
 			var ptr = gch.AddrOfPinnedObject () + offset;
+#if NET
+			unsafe {
+				return CGDataProviderCreateWithData (GCHandle.ToIntPtr (gch), ptr, count, &ReleaseGCHandle);
+			}
+#else
 			return CGDataProviderCreateWithData (GCHandle.ToIntPtr (gch), ptr, count, release_gchandle_callback);
+#endif
 		}
 
 		public CGDataProvider (byte [] buffer, int offset, int count)

src/CoreGraphics/CGFunction.cs

@@ -58,8 +58,13 @@ public class CGFunction : NativeObject {
 		unsafe static CGFunction ()
 		{
 			cbacks.version = 0;
+#if NET
+			cbacks.evaluate = &EvaluateCallback;
+			cbacks.release = &ReleaseCallback;
+#else
 			cbacks.evaluate = new CGFunctionEvaluateCallback (EvaluateCallback);
 			cbacks.release = new CGFunctionReleaseCallback (ReleaseCallback);
+#endif
 		}
 
 #if !NET
@@ -103,12 +108,17 @@ protected internal override void Release ()
 		// Apple's documentation says 'float', the header files say 'CGFloat'
 		unsafe delegate void CGFunctionEvaluateCallback (/* void* */ IntPtr info, /* CGFloat* */ nfloat *data, /* CGFloat* */ nfloat *outData); 
 		delegate void CGFunctionReleaseCallback (IntPtr info);
-			
+
 		[StructLayout (LayoutKind.Sequential)]
 		struct CGFunctionCallbacks {
 			public /* unsigned int */ uint version;
+#if NET
+			public unsafe delegate* unmanaged<IntPtr, nfloat*, nfloat*, void> evaluate;
+			public unsafe delegate* unmanaged<IntPtr, void> release;
+#else
 			public CGFunctionEvaluateCallback? evaluate;
 			public CGFunctionReleaseCallback? release;
+#endif
 		}
 
 		[DllImport (Constants.CoreGraphicsLibrary)]
@@ -136,17 +146,24 @@ public unsafe CGFunction (nfloat []? domain, nfloat []? range, CGFunctionEvaluat
 			var handle = CGFunctionCreate (GCHandle.ToIntPtr (gch), domain is not null ? domain.Length / 2 : 0, domain, range is not null ? range.Length / 2 : 0, range, ref cbacks);
 			InitializeHandle (handle);
 		}
-
+#if NET
+		[UnmanagedCallersOnly]
+#else
 #if !MONOMAC
 		[MonoPInvokeCallback (typeof (CGFunctionReleaseCallback))]
+#endif
 #endif
 		static void ReleaseCallback (IntPtr info)
 		{
 			GCHandle.FromIntPtr (info).Free ();
 		}
 
+#if NET
+		[UnmanagedCallersOnly]
+#else
 #if !MONOMAC
 		[MonoPInvokeCallback (typeof (CGFunctionEvaluateCallback))]
+#endif
 #endif
 		unsafe static void EvaluateCallback (IntPtr info, nfloat *input, nfloat *output)
 		{

src/CoreGraphics/CGPath.cs

@@ -481,9 +481,12 @@ public unsafe bool ContainsPoint (CGPoint point, bool eoFill)
 		public delegate void ApplierFunction (CGPathElement element);
 
 		delegate void CGPathApplierFunction (/* void* */ IntPtr info, /* const CGPathElement* */ IntPtr element);
-
+#if NET
+		[UnmanagedCallersOnly]
+#else		
 #if !MONOMAC
 		[MonoPInvokeCallback (typeof (CGPathApplierFunction))]
+#endif
 #endif
 		static void ApplierCallback (IntPtr info, IntPtr element_ptr)
 		{
@@ -523,12 +526,22 @@ static void ApplierCallback (IntPtr info, IntPtr element_ptr)
 
 
 		[DllImport (Constants.CoreGraphicsLibrary)]
+#if NET
+		extern unsafe static void CGPathApply (/* CGPathRef */ IntPtr path, /* void* */ IntPtr info, delegate* unmanaged<IntPtr, IntPtr, void> function);
+#else
 		extern static void CGPathApply (/* CGPathRef */ IntPtr path, /* void* */ IntPtr info, CGPathApplierFunction function);
+#endif
 
 		public void Apply (ApplierFunction func)
 		{
 			GCHandle gch = GCHandle.Alloc (func);
+#if NET
+			unsafe {
+				CGPathApply (Handle, GCHandle.ToIntPtr (gch), &ApplierCallback);
+			}
+#else
 			CGPathApply (Handle, GCHandle.ToIntPtr (gch), ApplierCallback);
+#endif
 			gch.Free ();
 		}
 

src/CoreGraphics/CGPattern.cs

@@ -56,8 +56,13 @@ public enum CGPatternTiling {
 	[StructLayout (LayoutKind.Sequential)]
 	struct CGPatternCallbacks {
 		internal /* unsigned int */ uint version;
+#if NET
+		internal unsafe delegate* unmanaged<IntPtr, IntPtr, void> draw;
+		internal unsafe delegate* unmanaged<IntPtr, void> release;
+#else
 		internal DrawPatternCallback draw;
 		internal ReleaseInfoCallback release;
+#endif
 	}
 
 
@@ -95,11 +100,25 @@ extern static IntPtr CGPatternCreate (/* void* */ IntPtr info, CGRect bounds, CG
 			/* CGFloat */ nfloat xStep, /* CGFloat */ nfloat yStep, CGPatternTiling tiling, [MarshalAs (UnmanagedType.I1)] bool isColored,
 			/* const CGPatternCallbacks* */ ref CGPatternCallbacks callbacks);
 
+#if NET
+		static CGPatternCallbacks callbacks;
+
+		static CGPattern () {
+			unsafe {
+				callbacks = new CGPatternCallbacks () {
+					version = 0,
+					draw = &DrawCallback,
+					release = &ReleaseCallback,
+				};
+			}
+		}
+#else
 		static CGPatternCallbacks callbacks = new CGPatternCallbacks () {
 			version = 0,
 			draw = DrawCallback,
 			release = ReleaseCallback,
 		};
+#endif
 		GCHandle gch;
 
 		public CGPattern (CGRect bounds, CGAffineTransform matrix, nfloat xStep, nfloat yStep, CGPatternTiling tiling, bool isColored, DrawPattern drawPattern)
@@ -111,8 +130,12 @@ public CGPattern (CGRect bounds, CGAffineTransform matrix, nfloat xStep, nfloat
 			Handle = CGPatternCreate (GCHandle.ToIntPtr (gch), bounds, matrix, xStep, yStep, tiling, isColored, ref callbacks);
 		}
 
+#if NET
+		[UnmanagedCallersOnly]
+#else
 #if !MONOMAC
 		[MonoPInvokeCallback (typeof (DrawPatternCallback))]
+#endif
 #endif
 		static void DrawCallback (IntPtr voidptr, IntPtr cgcontextptr)
 		{
@@ -123,8 +146,12 @@ static void DrawCallback (IntPtr voidptr, IntPtr cgcontextptr)
 			}
 		}
 
+#if NET
+		[UnmanagedCallersOnly]
+#else
 #if !MONOMAC
 		[MonoPInvokeCallback (typeof (ReleaseInfoCallback))]
+#endif
 #endif
 		static void ReleaseCallback (IntPtr voidptr)
 		{

tests/common/DotNet.cs

@@ -193,6 +193,9 @@ public static void CompareApps (string old_app, string new_app)
 						return false; // the .NET runtime will deal with selecting the http handler, no need for us to do anything
 					case "runtimeconfig.bin":
 						return false; // this file is present for .NET apps, but not legacy apps.
+					case "embedded.mobileprovision":
+					case "CodeResources":
+						return false; // sometimes we don't sign in .NET when we do in legacy (if there's an empty Entitlements.plist file)
 					}
 
 					var components = v.Split ('/');