[NearbyInteraction] Updates for Xcode14 Beta 1

src/NearbyInteraction/Enums.cs

@@ -24,6 +24,8 @@ public enum NIErrorCode : long
 		ResourceUsageTimeout = -5886,
 		ActiveSessionsLimitExceeded = -5885,
 		UserDidNotAllow = -5884,
+		AccessoryPeerDeviceUnavailable = -5882,
+		InvalidARConfiguration = -5883,
 	}
 
 	[Watch (8,0), NoTV, NoMac, iOS (14,0)]
@@ -33,4 +35,24 @@ public enum NINearbyObjectRemovalReason : long
 		Timeout,
 		PeerEnded,
 	}
+
+	[iOS (16,0), NoMac, Watch (9,0), NoTV, MacCatalyst (16,0)]
+	[Native]
+	public enum NIAlgorithmConvergenceStatus : long
+	{
+		Unknown,
+		NotConverged,
+		Converged,
+	}
+
+	[iOS (16,0), NoMac, Watch (9,0), NoTV, MacCatalyst (16,0)]
+	[Native]
+	public enum NINearbyObjectVerticalDirectionEstimate : long
+	{
+		Unknown = 0,
+		Same = 1,
+		Above = 2,
+		Below = 3,
+		AboveOrBelow = 4,
+	}
 }

src/NearbyInteraction/NIAlgorithmConvergenceStatusReasonValues.cs

@@ -0,0 +1,52 @@
+//
+// NIAlgorithmConvergenceStatusReasonDescription manual binding
+//
+// Authors:
+//	TJ Lambert  <TJ.Lambert@microsoft.com>
+//
+// Copyright 2022 Microsoft Corp.
+//
+
+#if IOS || WATCH || __MACCATALYST__
+
+#nullable enable
+
+using System;
+using System.Runtime.InteropServices;
+using CoreFoundation;
+using Foundation;
+using ObjCRuntime;
+
+#if !NET
+using NativeHandle = System.IntPtr;
+#endif
+
+namespace NearbyInteraction {
+	public partial class NIAlgorithmConvergenceStatusReasonValues
+	{
+#if NET
+		[SupportedOSPlatform ("ios16.0")]
+		[SupportedOSPlatform ("maccatalyst16.0")]
+		[UnsupportedOSPlatform ("tvos")]
+		[UnsupportedOSPlatform ("macos")]
+#else
+		[iOS (16,0), NoMac, Watch (9,0), NoTV, MacCatalyst (16,0)]
+#endif // NET
+		[DllImport (Constants.NearbyInteractionLibrary)]
+		static extern NativeHandle /* NSString */ NIAlgorithmConvergenceStatusReasonDescription (NativeHandle /* NIAlgorithmConvergenceStatusReason */ reason);
+
+#if NET
+		[SupportedOSPlatform ("ios16.0")]
+		[SupportedOSPlatform ("maccatalyst16.0")]
+		[UnsupportedOSPlatform ("tvos")]
+		[UnsupportedOSPlatform ("macos")]
+#else
+		[iOS (16,0), NoMac, Watch (9,0), NoTV, MacCatalyst (16,0)]
+#endif // NET
+		public static NSString GetConvergenceStatusReason (NIAlgorithmConvergenceStatusReason reason)
+		{
+			return Runtime.GetNSObject<NSString> (NIAlgorithmConvergenceStatusReasonDescription (reason.GetConstant ().GetHandle ()))!;
+		}
+	}
+}
+#endif // IOS || WATCH || __MACCATALYST__

src/NearbyInteraction/NINearbyObject.cs

@@ -17,8 +17,10 @@
 using ObjCRuntime;
 #if NET
 using Vector3 = global::System.Numerics.Vector3;
+using MatrixFloat4x4 = global::CoreGraphics.NMatrix4;
 #else
 using Vector3 = global::OpenTK.Vector3;
+using MatrixFloat4x4 = global::OpenTK.NMatrix4;
 #endif
 
 #if __IOS__ || WATCH
@@ -41,7 +43,22 @@ public static Vector3 DirectionNotAvailable {
 				return (Vector3)_DirectionNotAvailable;
 			}
 		}
-	}
 
+		static MatrixFloat4x4? _WorldTransformNotAvailable;
+
+		// Following similar strategy found here: https://github.com/xamarin/maccore/issues/2274
+		[Field ("NINearbyObjectWorldTransformNotAvailable",  "NearbyInteraction")]
+		public static MatrixFloat4x4 WorldTransformNotAvailable {
+			get {
+				if (_WorldTransformNotAvailable is null) {
+					unsafe {
+						MatrixFloat4x4 *pointer = (MatrixFloat4x4 *) Dlfcn.GetIndirect (Libraries.NearbyInteraction.Handle, "NINearbyObjectWorldTransformNotAvailable");
+						_WorldTransformNotAvailable = *pointer;
+					}
+				}
+				return (MatrixFloat4x4)_WorldTransformNotAvailable;
+			}
+		}
+	}
 }
 #endif

src/frameworks.sources

@@ -1321,6 +1321,7 @@ NEARBYINTERACTION_API_SOURCES = \
 
 NEARBYINTERACTION_SOURCES = \
 	NearbyInteraction/NINearbyObject.cs \
+	NearbyInteraction/NIAlgorithmConvergenceStatusReasonValues.cs \
 
 # NetworkExtension
 

src/nearbyinteraction.cs

@@ -11,10 +11,20 @@
 using Foundation;
 using CoreFoundation;
 using System;
+#if __MACCATALYST__
+using ARSession = Foundation.NSObject;
+#elif IOS
+using ARKit;
+#else
+using ARSession = Foundation.NSObject;
+#endif
+
 #if NET
 using Vector3 = global::System.Numerics.Vector3;
+using MatrixFloat4x4 = global::CoreGraphics.NMatrix4;
 #else
 using Vector3 = global::OpenTK.Vector3;
+using MatrixFloat4x4 = global::OpenTK.NMatrix4;
 #endif
 
 #if !NET
@@ -46,6 +56,10 @@ interface NINearbyPeerConfiguration
 
 		[Export ("initWithPeerToken:")]
 		NativeHandle Constructor (NIDiscoveryToken peerToken);
+
+		[NoWatch, iOS (16,0), MacCatalyst (16,0), NoTV, NoMac]
+		[Export ("cameraAssistanceEnabled")]
+		bool CameraAssistanceEnabled { [Bind ("isCameraAssistanceEnabled")] get; set; }
 	}
 
 	[Watch (8,0), NoTV, NoMac, iOS (14,0)]
@@ -68,6 +82,18 @@ Vector3 Direction {
 
 		[Field ("NINearbyObjectDistanceNotAvailable")]
 		float DistanceNotAvailable { get; }
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Field ("NINearbyObjectAngleNotAvailable")]
+		float AngleNotAvailable { get; }
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Export ("verticalDirectionEstimate")]
+		NINearbyObjectVerticalDirectionEstimate VerticalDirectionEstimate { get; }
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Export ("horizontalAngle")]
+		float HorizontalAngle { get; }
 	}
 
 	[Watch (8,0), NoTV, NoMac, iOS (14,0)]
@@ -103,6 +129,20 @@ interface NISession
 
 		[Export ("invalidate")]
 		void Invalidate ();
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Export ("setARSession:")]
+		void SetARSession (ARSession session);
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Export ("worldTransformForObject:")]
+		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
+		MatrixFloat4x4 GetWorldTransform (NINearbyObject @object);
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Static]
+		[Export ("deviceCapabilities")]
+		INIDeviceCapability DeviceCapabilities { get; }
 	}
 
 	interface INISessionDelegate {}
@@ -136,6 +176,14 @@ interface NISessionDelegate
 		[Watch (8,0), NoTV, NoMac, iOS (15,0), MacCatalyst (15,0)]
 		[Export ("session:didGenerateShareableConfigurationData:forObject:")]
 		void DidGenerateShareableConfigurationData (NISession session, NSData shareableConfigurationData, NINearbyObject @object);
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Export ("session:didUpdateAlgorithmConvergence:forObject:")]
+		void DidUpdateAlgorithmConvergence (NISession session, NIAlgorithmConvergence convergence, [NullAllowed] NINearbyObject @object);
+
+		[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+		[Export ("sessionDidStartRunning:")]
+		void SessionDidStartRunning (NISession session);
 	}
 
 	[Watch (8,0), NoTV, NoMac, iOS (15,0), MacCatalyst (15,0)]
@@ -148,6 +196,60 @@ interface NINearbyAccessoryConfiguration
 
 		[Export ("initWithData:error:")]
 		NativeHandle Constructor (NSData data, [NullAllowed] out NSError error);
+
+		[iOS (16,0), NoMac, NoWatch, NoTV, MacCatalyst (16,0)]
+		[Export ("initWithAccessoryData:bluetoothPeerIdentifier:error:")]
+		NativeHandle Constructor (NSData accessoryData, NSUuid identifier, [NullAllowed] out NSError error);
+
+		[iOS (16,0), NoMac, NoWatch, NoTV, MacCatalyst (16,0)]
+		[Export ("cameraAssistanceEnabled")]
+		bool CameraAssistanceEnabled { [Bind ("isCameraAssistanceEnabled")] get; set; }
 	}
 
+	[iOS (16,0), NoMac, Watch (9,0), NoTV, MacCatalyst (16,0)]
+	public enum NIAlgorithmConvergenceStatusReason
+	{
+		[Field ("NIAlgorithmConvergenceStatusReasonInsufficientHorizontalSweep")]
+		InsufficientHorizontalSweep,
+
+		[Field ("NIAlgorithmConvergenceStatusReasonInsufficientVerticalSweep")]
+		InsufficientVerticalSweep,
+
+		[Field ("NIAlgorithmConvergenceStatusReasonInsufficientMovement")]
+		InsufficientMovement,
+
+		[Field ("NIAlgorithmConvergenceStatusReasonInsufficientLighting")]
+		InsufficientLighting,
+	}
+
+	interface INIDeviceCapability {}
+
+	[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+	[Protocol]
+	interface NIDeviceCapability
+	{
+		[Abstract]
+		[Export ("supportsPreciseDistanceMeasurement")]
+		bool SupportsPreciseDistanceMeasurement { get; }
+
+		[Abstract]
+		[Export ("supportsDirectionMeasurement")]
+		bool SupportsDirectionMeasurement { get; }
+
+		[Abstract]
+		[Export ("supportsCameraAssistance")]
+		bool SupportsCameraAssistance { get; }
+	}
+
+	[Watch (9,0), NoTV, NoMac, iOS (16,0), MacCatalyst (16,0)]
+	[BaseType (typeof (NSObject))]
+	[DisableDefaultCtor]
+	interface NIAlgorithmConvergence : NSCopying, NSSecureCoding
+	{
+		[Export ("status")]
+		NIAlgorithmConvergenceStatus Status { get; }
+
+		[Export ("reasons")]
+		string[] Reasons { get; }
+	}
 }

tests/monotouch-test/NearbyInteraction/NIAlgorithmConvergenceStatusReasonValuesTest.cs

@@ -0,0 +1,33 @@
+// Copyright 2022 Microsoft Corp.
+
+#if IOS || WATCH || __MACCATALYST__
+
+using System;
+using Foundation;
+using ObjCRuntime;
+using NearbyInteraction;
+using NUnit.Framework;
+using Xamarin.Utils;
+
+namespace MonoTouchFixtures.NearbyInteraction {
+
+	[TestFixture]
+	[Preserve (AllMembers = true)]
+	public class NIAlgorithmConvergenceStatusReasonValuesTest {
+
+		[SetUp]
+		public void Setup ()
+		{
+			TestRuntime.AssertXcodeVersion (14, 0);
+		}
+
+		[Test]
+		public void GetConvergenceStatusReasonTest ()
+		{
+			var reason = NIAlgorithmConvergenceStatusReason.InsufficientHorizontalSweep;
+			Assert.IsNotNull (NIAlgorithmConvergenceStatusReasonValues.GetConvergenceStatusReason (reason), "NIAlgorithmConvergenceStatusReason should not be null.");
+		}
+	}
+}
+
+#endif // IOS || WATCH || __MACCATALYST__

tests/monotouch-test/NearbyInteraction/NINearbyObjectTest.cs

@@ -11,8 +11,10 @@
 
 #if NET
 using System.Numerics;
+using MatrixFloat4x4 = global::CoreGraphics.NMatrix4;
 #else
 using OpenTK;
+using MatrixFloat4x4 = global::OpenTK.NMatrix4;
 #endif
 
 namespace MonoTouchFixtures.NearbyInteraction {
@@ -42,6 +44,22 @@ public void DirectionNotAvailable ()
 					Assert.That (ptr [i], Is.EqualTo (zero), $"Position {i}");
 			}
 		}
+
+		[Test]
+		public void WorldTransformNotAvailable ()
+		{
+			TestRuntime.AssertXcodeVersion (14, 0);
+
+			MatrixFloat4x4 matrix = NINearbyObject.WorldTransformNotAvailable;
+
+			unsafe {
+				MatrixFloat4x4* m = &matrix;
+				byte* ptr = (byte*) m;
+				byte zero = 0;
+				for (var i = 0; i < sizeof (MatrixFloat4x4); i++)
+					Assert.That (ptr [i], Is.EqualTo (zero), $"Position {i}");
+			}
+		}
 	}
 }