using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Threading.Tasks;
using Windows.ApplicationModel;
using Windows.Devices.Bluetooth;
using Windows.Devices.Bluetooth.Advertisement;
using Windows.Devices.Bluetooth.GenericAttributeProfile;
using Windows.Devices.Enumeration;
using Windows.Devices.Radios;
using Windows.Foundation;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("In The Hand Ltd")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2004-2022 In The Hand Ltd")]
[assembly: AssemblyDescription("32feet.NET is an open-source project to make personal area networking technologies such as Bluetooth easily accessible from .NET code.")]
[assembly: AssemblyFileVersion("4.0.23.327")]
[assembly: AssemblyInformationalVersion("4.0.23+7156b6d5e96fc1f09828f6fa454a3f57433aa896")]
[assembly: AssemblyProduct("32feet.NET")]
[assembly: AssemblyTitle("InTheHand.BluetoothLE")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/inthehand/32feet")]
[assembly: TargetPlatform("Windows10.0.19041.0")]
[assembly: SupportedOSPlatform("Windows10.0.17763.0")]
[assembly: AssemblyVersion("4.0.0.0")]
namespace InTheHand.Bluetooth;
public static class Bluetooth
{
[ComImport]
[Guid("3E68D4BD-7135-4D10-8018-9FB6D9F33FA1")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IInitializeWithWindow
{
void Initialize(IntPtr hwnd);
}
internal static Dictionary<ulong, WeakReference> KnownDevices = new Dictionary<ulong, WeakReference>();
private static bool _oldAvailability;
private static event EventHandler availabilityChanged;
public static event EventHandler AvailabilityChanged
{
add
{
if (Bluetooth.availabilityChanged == null)
{
AddAvailabilityChanged();
}
availabilityChanged += value;
}
remove
{
availabilityChanged -= value;
if (Bluetooth.availabilityChanged == null)
{
RemoveAvailabilityChanged();
}
}
}
public static event EventHandler<BluetoothAdvertisingEvent> AdvertisementReceived;
public static Task<bool> GetAvailabilityAsync()
{
return PlatformGetAvailability();
}
public static Task<BluetoothDevice> RequestDeviceAsync(RequestDeviceOptions options = null)
{
ThrowOnInvalidOptions(options);
return PlatformRequestDevice(options);
}
private static void ThrowOnInvalidOptions(RequestDeviceOptions options)
{
if (options != null && (options.Filters != null && options.Filters.Count > 0) == options.AcceptAllDevices)
{
throw new ArgumentException("Cannot set both Filters and AcceptAllDevices");
}
}
private static void OnAvailabilityChanged()
{
Bluetooth.availabilityChanged?.Invoke(null, EventArgs.Empty);
}
public static Task<IReadOnlyCollection<BluetoothDevice>> GetPairedDevicesAsync()
{
return PlatformGetPairedDevices();
}
public static Task<IReadOnlyCollection<BluetoothDevice>> ScanForDevicesAsync(RequestDeviceOptions options = null)
{
ThrowOnInvalidOptions(options);
return PlatformScanForDevices(options);
}
public static Task<BluetoothLEScan> RequestLEScanAsync(BluetoothLEScanOptions options = null)
{
return PlatformRequestLEScan(options);
}
internal static void OnAdvertisementReceived(BluetoothAdvertisingEvent advertisingEvent)
{
Bluetooth.AdvertisementReceived?.Invoke(null, advertisingEvent);
}
private static async Task<bool> PlatformGetAvailability()
{
TaskAwaiter<BluetoothAdapter> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothAdapter>(BluetoothAdapter.GetDefaultAsync());
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<BluetoothAdapter> taskAwaiter2 = default(TaskAwaiter<BluetoothAdapter>);
taskAwaiter = taskAwaiter2;
}
BluetoothAdapter result = taskAwaiter.GetResult();
BluetoothAdapter val = result;
return val.IsLowEnergySupported;
}
private static async Task<BluetoothDevice> PlatformRequestDevice(RequestDeviceOptions options)
{
DevicePicker val = new DevicePicker();
Rect val2 = Rect.Empty;
uint bufferLength = 64u;
byte[] buffer = new byte[bufferLength];
_ = IntPtr.Zero;
try
{
if (!string.IsNullOrEmpty(Console.Title))
{
val2 = new Rect(0f, 0f, 480f, 480f);
IntPtr consoleWindow = GetConsoleWindow();
((IInitializeWithWindow)val).Initialize(consoleWindow);
}
}
catch
{
}
int currentPackageId = GetCurrentPackageId(ref bufferLength, buffer);
if (currentPackageId == 15700)
{
using IEnumerator<Attribute> enumerator = Assembly.GetEntryAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute)).GetEnumerator();
if (enumerator.MoveNext())
{
Attribute current = enumerator.Current;
val.Appearance.Title = ((AssemblyProductAttribute)current).Product + " wants to pair";
}
}
else
{
val.Appearance.Title = Package.Current.DisplayName + " wants to pair";
}
if (options != null && !options.AcceptAllDevices)
{
foreach (BluetoothLEScanFilter filter in options.Filters)
{
if (!string.IsNullOrEmpty(filter.Name))
{
val.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromDeviceName(filter.Name));
}
foreach (BluetoothUuid service in filter.Services)
{
val.Filter.SupportedDeviceSelectors.Add(GattDeviceService.GetDeviceSelectorFromUuid((Guid)service));
}
}
}
if (val.Filter.SupportedDeviceSelectors.Count == 0)
{
val.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromPairingState(true));
val.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromPairingState(false));
}
try
{
TaskAwaiter<DeviceInformation> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<DeviceInformation>(val.PickSingleDeviceAsync(val2));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<DeviceInformation> taskAwaiter2 = default(TaskAwaiter<DeviceInformation>);
taskAwaiter = taskAwaiter2;
}
DeviceInformation result = taskAwaiter.GetResult();
DeviceInformation val3 = result;
if (val3 == (DeviceInformation)null)
{
return null;
}
TaskAwaiter<BluetoothLEDevice> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothLEDevice>(BluetoothLEDevice.FromIdAsync(val3.Id));
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
TaskAwaiter<BluetoothLEDevice> taskAwaiter4 = default(TaskAwaiter<BluetoothLEDevice>);
taskAwaiter3 = taskAwaiter4;
}
BluetoothLEDevice result2 = taskAwaiter3.GetResult();
BluetoothLEDevice device = result2;
TaskAwaiter<DeviceAccessStatus> taskAwaiter5 = WindowsRuntimeSystemExtensions.GetAwaiter<DeviceAccessStatus>(device.RequestAccessAsync());
if (!taskAwaiter5.IsCompleted)
{
await taskAwaiter5;
TaskAwaiter<DeviceAccessStatus> taskAwaiter6 = default(TaskAwaiter<DeviceAccessStatus>);
taskAwaiter5 = taskAwaiter6;
}
taskAwaiter5.GetResult();
return new BluetoothDevice(device);
}
catch (Exception ex)
{
if (ex.HResult == -2147023496)
{
throw new PlatformNotSupportedException("RequestDevice cannot be called from a Console application.");
}
return null;
}
}
private static async Task<IReadOnlyCollection<BluetoothDevice>> PlatformScanForDevices(RequestDeviceOptions options)
{
List<BluetoothDevice> devices = new List<BluetoothDevice>();
TaskAwaiter<DeviceInformationCollection> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<DeviceInformationCollection>(DeviceInformation.FindAllAsync("System.Devices.DevObjectType:=5 AND System.Devices.Aep.ProtocolId:=\"{BB7BB05E-5972-42B5-94FC-76EAA7084D49}\" AND (System.Devices.Aep.IsPaired:=System.StructuredQueryType.Boolean#False OR System.Devices.Aep.IsPaired:=System.StructuredQueryType.Boolean#True OR System.Devices.Aep.Bluetooth.IssueInquiry:=System.StructuredQueryType.Boolean#True)"));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<DeviceInformationCollection> taskAwaiter2 = default(TaskAwaiter<DeviceInformationCollection>);
taskAwaiter = taskAwaiter2;
}
DeviceInformationCollection result = taskAwaiter.GetResult();
TaskAwaiter<BluetoothLEDevice> taskAwaiter4 = default(TaskAwaiter<BluetoothLEDevice>);
foreach (DeviceInformation item in result)
{
try
{
List<BluetoothDevice> list = devices;
TaskAwaiter<BluetoothLEDevice> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothLEDevice>(BluetoothLEDevice.FromIdAsync(item.Id));
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
taskAwaiter3 = taskAwaiter4;
taskAwaiter4 = default(TaskAwaiter<BluetoothLEDevice>);
}
BluetoothLEDevice result2 = taskAwaiter3.GetResult();
list.Add(result2);
}
catch (ArgumentException)
{
}
}
return devices.AsReadOnly();
}
private static async Task<IReadOnlyCollection<BluetoothDevice>> PlatformGetPairedDevices()
{
List<BluetoothDevice> devices = new List<BluetoothDevice>();
TaskAwaiter<DeviceInformationCollection> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<DeviceInformationCollection>(DeviceInformation.FindAllAsync(BluetoothLEDevice.GetDeviceSelectorFromPairingState(true)));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<DeviceInformationCollection> taskAwaiter2 = default(TaskAwaiter<DeviceInformationCollection>);
taskAwaiter = taskAwaiter2;
}
DeviceInformationCollection result = taskAwaiter.GetResult();
TaskAwaiter<BluetoothLEDevice> taskAwaiter4 = default(TaskAwaiter<BluetoothLEDevice>);
foreach (DeviceInformation item in result)
{
try
{
List<BluetoothDevice> list = devices;
TaskAwaiter<BluetoothLEDevice> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothLEDevice>(BluetoothLEDevice.FromIdAsync(item.Id));
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
taskAwaiter3 = taskAwaiter4;
taskAwaiter4 = default(TaskAwaiter<BluetoothLEDevice>);
}
BluetoothLEDevice result2 = taskAwaiter3.GetResult();
list.Add(result2);
}
catch (ArgumentException)
{
}
}
return devices.AsReadOnly();
}
private static async void AddAvailabilityChanged()
{
_oldAvailability = await PlatformGetAvailability();
TaskAwaiter<BluetoothAdapter> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothAdapter>(BluetoothAdapter.GetDefaultAsync());
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<BluetoothAdapter> taskAwaiter2 = default(TaskAwaiter<BluetoothAdapter>);
taskAwaiter = taskAwaiter2;
}
BluetoothAdapter result = taskAwaiter.GetResult();
BluetoothAdapter val = result;
TaskAwaiter<Radio> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<Radio>(val.GetRadioAsync());
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
TaskAwaiter<Radio> taskAwaiter4 = default(TaskAwaiter<Radio>);
taskAwaiter3 = taskAwaiter4;
}
Radio result2 = taskAwaiter3.GetResult();
Radio val2 = result2;
val2.StateChanged += Radio_StateChanged;
}
private static async void Radio_StateChanged(Radio sender, object args)
{
bool flag = await PlatformGetAvailability();
if (flag != _oldAvailability)
{
_oldAvailability = flag;
OnAvailabilityChanged();
}
}
private static async void RemoveAvailabilityChanged()
{
TaskAwaiter<BluetoothAdapter> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothAdapter>(BluetoothAdapter.GetDefaultAsync());
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<BluetoothAdapter> taskAwaiter2 = default(TaskAwaiter<BluetoothAdapter>);
taskAwaiter = taskAwaiter2;
}
BluetoothAdapter result = taskAwaiter.GetResult();
BluetoothAdapter val = result;
TaskAwaiter<Radio> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<Radio>(val.GetRadioAsync());
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
TaskAwaiter<Radio> taskAwaiter4 = default(TaskAwaiter<Radio>);
taskAwaiter3 = taskAwaiter4;
}
Radio result2 = taskAwaiter3.GetResult();
Radio val2 = result2;
val2.StateChanged -= Radio_StateChanged;
}
private static async Task<BluetoothLEScan> PlatformRequestLEScan(BluetoothLEScanOptions options)
{
if (options == null)
{
return (BluetoothLEScan)new BluetoothLEAdvertisementWatcher();
}
return (BluetoothLEScan)new BluetoothLEAdvertisementWatcher((BluetoothLEAdvertisementFilter)options);
}
private static void Watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
Bluetooth.AdvertisementReceived?.Invoke(null, args);
}
[DllImport("Kernel32", ExactSpelling = true, SetLastError = true)]
private static extern int GetCurrentPackageId(ref uint bufferLength, byte[] buffer);
[DllImport("Kernel32")]
private static extern IntPtr GetConsoleWindow();
[DllImport("User32")]
private static extern IntPtr GetActiveWindow();
}
public sealed class BluetoothAdvertisingEvent
{
private readonly short _rssi;
private readonly BluetoothLEAdvertisement _advertisement;
private ushort _appearance;
private sbyte _txPower;
public BluetoothDevice Device { get; private set; }
public BluetoothUuid[] Uuids => GetUuids();
public string Name => GetName();
public ushort Appearance => GetAppearance();
public sbyte TxPower => GetTxPower();
public short Rssi => GetRssi();
public IReadOnlyDictionary<ushort, byte[]> ManufacturerData => GetManufacturerData();
public IReadOnlyDictionary<BluetoothUuid, byte[]> ServiceData => GetServiceData();
internal BluetoothAdvertisingEvent(BluetoothDevice device)
{
Device = device;
}
internal BluetoothAdvertisingEvent(BluetoothLEAdvertisementReceivedEventArgs args)
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
_rssi = args.RawSignalStrengthInDBm;
_txPower = (sbyte)(args.TransmitPowerLevelInDBm.HasValue ? ((sbyte)args.TransmitPowerLevelInDBm.Value) : 0);
IReadOnlyList<BluetoothLEAdvertisementDataSection> sectionsByType = args.Advertisement.GetSectionsByType((byte)25);
if (sectionsByType != null && sectionsByType.Count > 0)
{
byte[] value = WindowsRuntimeBufferExtensions.ToArray(sectionsByType[0].Data);
_appearance = BitConverter.ToUInt16(value, 0);
}
IAsyncOperation<BluetoothLEDevice> val = BluetoothLEDevice.FromBluetoothAddressAsync(args.BluetoothAddress, args.BluetoothAddressType);
if (WindowsRuntimeSystemExtensions.AsTask<BluetoothLEDevice>(val).Wait(7000))
{
Device = val.GetResults();
}
else
{
try
{
((IAsyncInfo)val).Cancel();
}
catch
{
}
}
_advertisement = args.Advertisement;
}
public static implicit operator BluetoothAdvertisingEvent(BluetoothLEAdvertisementReceivedEventArgs args)
{
return new BluetoothAdvertisingEvent(args);
}
private ushort GetAppearance()
{
return _appearance;
}
private short GetRssi()
{
return _rssi;
}
private sbyte GetTxPower()
{
return _txPower;
}
private BluetoothUuid[] GetUuids()
{
List<BluetoothUuid> list = new List<BluetoothUuid>();
foreach (Guid serviceUuid in _advertisement.ServiceUuids)
{
list.Add(serviceUuid);
}
return list.ToArray();
}
private string GetName()
{
return _advertisement.LocalName;
}
private IReadOnlyDictionary<ushort, byte[]> GetManufacturerData()
{
Dictionary<ushort, byte[]> dictionary = new Dictionary<ushort, byte[]>();
foreach (BluetoothLEManufacturerData manufacturerDatum in _advertisement.ManufacturerData)
{
dictionary.Add(manufacturerDatum.CompanyId, WindowsRuntimeBufferExtensions.ToArray(manufacturerDatum.Data));
}
return new ReadOnlyDictionary<ushort, byte[]>(dictionary);
}
private IReadOnlyDictionary<BluetoothUuid, byte[]> GetServiceData()
{
Dictionary<BluetoothUuid, byte[]> dictionary = new Dictionary<BluetoothUuid, byte[]>();
foreach (BluetoothLEAdvertisementDataSection dataSection in _advertisement.DataSections)
{
byte[] array = new byte[16];
if (dataSection.DataType == BluetoothLEAdvertisementDataTypes.ServiceData128BitUuids)
{
WindowsRuntimeBufferExtensions.CopyTo(dataSection.Data, 0u, array, 0, 16);
byte[] array2 = new byte[dataSection.Data.Length - 16];
WindowsRuntimeBufferExtensions.CopyTo(dataSection.Data, 16u, array2, 0, array2.Length);
dictionary.Add(new Guid(array), array2);
}
else if (dataSection.DataType == BluetoothLEAdvertisementDataTypes.ServiceData32BitUuids)
{
WindowsRuntimeBufferExtensions.CopyTo(dataSection.Data, 0u, array, 0, 4);
byte[] array3 = new byte[dataSection.Data.Length - 4];
WindowsRuntimeBufferExtensions.CopyTo(dataSection.Data, 4u, array3, 0, array3.Length);
dictionary.Add(BluetoothUuid.FromShortId(BitConverter.ToUInt16(array, 0)), array3);
}
else if (dataSection.DataType == BluetoothLEAdvertisementDataTypes.ServiceData16BitUuids)
{
WindowsRuntimeBufferExtensions.CopyTo(dataSection.Data, 0u, array, 0, 2);
byte[] array4 = new byte[dataSection.Data.Length - 2];
WindowsRuntimeBufferExtensions.CopyTo(dataSection.Data, 2u, array4, 0, array4.Length);
dictionary.Add(BluetoothUuid.FromShortId(BitConverter.ToUInt16(array, 0)), array4);
}
else
{
_ = dataSection.DataType;
_ = BluetoothLEAdvertisementDataTypes.Flags;
}
}
return new ReadOnlyDictionary<BluetoothUuid, byte[]>(dictionary);
}
}
public enum BluetoothAppearance : ushort
{
Unknown = 0,
GenericPhone = 64,
GenericComputer = 128,
GenericWatch = 192,
GenericClock = 256,
GenericDisplay = 320,
GenericRemoteControl = 384,
GenericEyeGlasses = 448,
GenericTag = 512,
GenericKeyring = 576,
GenericMediaPlayer = 640,
GenericBarcodeScanner = 704,
GenericThermometer = 768,
GenericHeartRateSensor = 832,
GenericBloodPressure = 896,
GenericHumanInterfaceDevice = 960,
GenericGlucoseMeter = 1024,
GenericRunningWalkingSensor = 1088,
GenericCycling = 1152,
GenericControlDevice = 1216,
GenericNetworkDevice = 1280,
GenericSensor = 1344,
GenericLightFixture = 1408,
GenericFan = 1472,
GenericHvac = 1536,
GenericAirConditioning = 1600,
GenericHumidifier = 1664,
GenericHeating = 1728,
GenericAccessControl = 1792,
GenericMotorizedDevice = 1856,
GenericPowerDevice = 1920,
GenericLightSource = 1984,
GenericPulseOximeter = 3136,
GenericWeightScale = 3200,
GenericOutdoorSportsActivity = 5184
}
[DebuggerDisplay("{Id} ({Name})")]
public sealed class BluetoothDevice
{
internal BluetoothLEDevice NativeDevice;
internal readonly ConcurrentDictionary<int, IDisposable> NativeDisposeList = new ConcurrentDictionary<int, IDisposable>();
private string _cachedId;
private string _cachedName;
internal ulong LastKnownAddress;
private RemoteGattServer _remoteGattServer;
public string Id => GetId();
public string Name => GetName();
public RemoteGattServer Gatt => GetGatt();
public event EventHandler GattServerDisconnected;
public static Task<BluetoothDevice> FromIdAsync(string id)
{
return PlatformFromId(id);
}
internal void OnGattServerDisconnected()
{
this.GattServerDisconnected?.Invoke(this, EventArgs.Empty);
}
public override bool Equals(object obj)
{
if (obj is BluetoothDevice bluetoothDevice)
{
return Id.Equals(bluetoothDevice.Id);
}
return base.Equals(obj);
}
internal BluetoothDevice(BluetoothLEDevice device)
{
NativeDevice = device;
AddDisposableObject(this, (IDisposable)device);
if (!(device == (BluetoothLEDevice)null))
{
LastKnownAddress = device.BluetoothAddress;
GetId();
GetName();
}
}
~BluetoothDevice()
{
DisposeAllNativeObjects();
}
internal void AddDisposableObject(object container, IDisposable disposableObject)
{
if (NativeDisposeList.TryGetValue(container.GetHashCode(), out var value))
{
NativeDisposeList.TryUpdate(container.GetHashCode(), disposableObject, value);
}
else
{
NativeDisposeList.TryAdd(container.GetHashCode(), disposableObject);
}
}
internal void DisposeAllNativeObjects()
{
Dictionary<int, IDisposable> dictionary = new Dictionary<int, IDisposable>();
foreach (KeyValuePair<int, IDisposable> nativeDispose in NativeDisposeList)
{
nativeDispose.Value?.Dispose();
dictionary.Add(nativeDispose.Key, nativeDispose.Value);
}
foreach (KeyValuePair<int, IDisposable> item in dictionary)
{
NativeDisposeList.TryUpdate(item.Key, null, item.Value);
}
}
internal async Task<bool> CreateNativeInstance()
{
if (LastKnownAddress == 0L)
{
return false;
}
if (NativeDisposeList.TryGetValue(GetHashCode(), out var value) && value == null)
{
TaskAwaiter<BluetoothLEDevice> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothLEDevice>(BluetoothLEDevice.FromBluetoothAddressAsync(LastKnownAddress));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<BluetoothLEDevice> taskAwaiter2 = default(TaskAwaiter<BluetoothLEDevice>);
taskAwaiter = taskAwaiter2;
}
BluetoothLEDevice result = taskAwaiter.GetResult();
BluetoothLEDevice val = result;
if (val != (BluetoothLEDevice)null)
{
AddDisposableObject(this, (IDisposable)val);
NativeDevice = val;
return true;
}
}
return false;
}
internal bool IsDisposedItem(object container)
{
if (NativeDisposeList.TryGetValue(container.GetHashCode(), out var value))
{
return value == null;
}
return false;
}
public static implicit operator BluetoothLEDevice(BluetoothDevice device)
{
return device.NativeDevice;
}
public static implicit operator BluetoothDevice(BluetoothLEDevice device)
{
if (!(device == (BluetoothLEDevice)null))
{
return new BluetoothDevice(device);
}
return null;
}
private static async Task<BluetoothDevice> PlatformFromId(string id)
{
TaskAwaiter<BluetoothLEDevice> taskAwaiter2 = default(TaskAwaiter<BluetoothLEDevice>);
BluetoothLEDevice device;
if (ulong.TryParse(id, NumberStyles.HexNumber, null, out var result))
{
if (Bluetooth.KnownDevices.ContainsKey(result))
{
BluetoothDevice bluetoothDevice = (BluetoothDevice)Bluetooth.KnownDevices[result].Target;
if (bluetoothDevice != null)
{
return bluetoothDevice;
}
}
TaskAwaiter<BluetoothLEDevice> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothLEDevice>(BluetoothLEDevice.FromBluetoothAddressAsync(result));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
taskAwaiter = taskAwaiter2;
}
BluetoothLEDevice result2 = taskAwaiter.GetResult();
device = result2;
}
else
{
TaskAwaiter<BluetoothLEDevice> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<BluetoothLEDevice>(BluetoothLEDevice.FromIdAsync(id));
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
taskAwaiter3 = taskAwaiter2;
}
BluetoothLEDevice result3 = taskAwaiter3.GetResult();
device = result3;
}
if (device != (BluetoothLEDevice)null)
{
TaskAwaiter<DeviceAccessStatus> taskAwaiter4 = WindowsRuntimeSystemExtensions.GetAwaiter<DeviceAccessStatus>(device.RequestAccessAsync());
if (!taskAwaiter4.IsCompleted)
{
await taskAwaiter4;
TaskAwaiter<DeviceAccessStatus> taskAwaiter5 = default(TaskAwaiter<DeviceAccessStatus>);
taskAwaiter4 = taskAwaiter5;
}
taskAwaiter4.GetResult();
}
return device;
}
internal string GetId()
{
if (IsDisposedItem(this))
{
return _cachedId;
}
_cachedId = NativeDevice.BluetoothAddress.ToString("X6");
return _cachedId;
}
internal string GetName()
{
if (IsDisposedItem(this))
{
return _cachedName;
}
if (NativeDevice.Name.StartsWith("Bluetooth "))
{
_cachedName = NativeDevice.DeviceInformation.Name;
}
else
{
_cachedName = NativeDevice.Name;
}
return _cachedName;
}
private RemoteGattServer GetGatt()
{
if (_remoteGattServer == null)
{
_remoteGattServer = new RemoteGattServer(this);
}
return _remoteGattServer;
}
}
public sealed class BluetoothLEScan
{
private List<BluetoothLEScanFilter> _filters = new List<BluetoothLEScanFilter>();
private readonly BluetoothLEAdvertisementWatcher _watcher;
public IReadOnlyList<BluetoothLEScanFilter> Filters => _filters.AsReadOnly();
public bool KeepRepeatedDevices => PlatformKeepRepeatedDevices;
public bool AcceptAllAdvertisements => PlatformAcceptAllAdvertisements;
public bool Active { get; private set; }
private bool PlatformAcceptAllAdvertisements => _watcher.AdvertisementFilter == (BluetoothLEAdvertisementFilter)null;
private bool PlatformKeepRepeatedDevices => true;
internal BluetoothLEScan()
{
}
public void Stop()
{
Active = false;
PlatformStop();
}
private BluetoothLEScan(BluetoothLEAdvertisementWatcher watcher)
{
_watcher = watcher;
_watcher.Received += _watcher_Received;
_watcher.Start();
Active = true;
}
public static implicit operator BluetoothLEAdvertisementWatcher(BluetoothLEScan scan)
{
return scan._watcher;
}
public static implicit operator BluetoothLEScan(BluetoothLEAdvertisementWatcher watcher)
{
return new BluetoothLEScan(watcher);
}
private void _watcher_Received(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
{
Bluetooth.OnAdvertisementReceived(args);
}
private void PlatformStop()
{
_watcher.Stop();
}
}
public sealed class BluetoothLEScanFilter
{
public IList<BluetoothUuid> Services { get; } = new List<BluetoothUuid>();
public string Name { get; set; }
public string NamePrefix { get; set; }
}
public sealed class BluetoothLEScanOptions
{
public readonly List<BluetoothLEScanFilter> Filters = new List<BluetoothLEScanFilter>();
private readonly BluetoothLEAdvertisementFilter _platformFilter;
public bool KeepRepeatedDevices { get; set; }
public bool AcceptAllAdvertisements { get; set; }
public BluetoothLEScanOptions()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
_platformFilter = new BluetoothLEAdvertisementFilter();
}
internal BluetoothLEScanOptions(BluetoothLEAdvertisementFilter filter)
{
_platformFilter = filter;
}
public static implicit operator BluetoothLEAdvertisementFilter(BluetoothLEScanOptions options)
{
return options._platformFilter;
}
public static implicit operator BluetoothLEScanOptions(BluetoothLEAdvertisementFilter filter)
{
return new BluetoothLEScanOptions(filter);
}
}
public enum BluetoothPhy
{
Le1m = 1,
Le2m,
LeCoded
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Field)]
public sealed class BluetoothUtiAttribute : Attribute
{
public string Uti { get; private set; }
public BluetoothUtiAttribute()
{
}
public BluetoothUtiAttribute(string uti)
{
Uti = uti;
}
}
[DebuggerDisplay("{ToString()}")]
public struct BluetoothUuid
{
internal static readonly Guid BluetoothBase = new Guid(0, 0, 4096, 128, 0, 0, 128, 95, 155, 52, 251);
private Guid _uuid;
[DebuggerDisplay("{0}")]
public Guid Value => _uuid;
public static BluetoothUuid Empty => default(BluetoothUuid);
private BluetoothUuid(Guid uuid)
{
_uuid = uuid;
}
public static implicit operator Guid(BluetoothUuid uuid)
{
return uuid._uuid;
}
public static implicit operator BluetoothUuid(Guid uuid)
{
return new BluetoothUuid(uuid);
}
public static implicit operator BluetoothUuid(ushort uuid)
{
return FromShortId(uuid);
}
public static explicit operator BluetoothUuid(string uuid)
{
return FromId(uuid);
}
public static explicit operator ushort(BluetoothUuid uuid)
{
ushort? num = TryGetShortId(uuid);
if (num.HasValue)
{
return num.Value;
}
return 0;
}
public static bool operator ==(BluetoothUuid uuid1, BluetoothUuid uuid2)
{
return uuid1.Value == uuid2.Value;
}
public static bool operator ==(BluetoothUuid uuid1, Guid uuid2)
{
return uuid1.Value == uuid2;
}
public static bool operator !=(BluetoothUuid uuid1, BluetoothUuid uuid2)
{
return uuid1.Value != uuid2.Value;
}
public static bool operator !=(BluetoothUuid uuid1, Guid uuid2)
{
return uuid1.Value != uuid2;
}
public override bool Equals(object obj)
{
if (obj is BluetoothUuid bluetoothUuid)
{
return Value == bluetoothUuid.Value;
}
if (obj is ushort num)
{
ushort? num2 = TryGetShortId(Value);
if (num2.HasValue && num2.Value == num)
{
return true;
}
}
else if (obj is Guid guid)
{
return Value == guid;
}
return false;
}
public override int GetHashCode()
{
return Value.GetHashCode();
}
public override string ToString()
{
ushort? num = TryGetShortId(Value);
if (num.HasValue)
{
return num.Value.ToString("X4");
}
return Value.ToString();
}
public static BluetoothUuid FromGuid(Guid uuid)
{
return new BluetoothUuid(uuid);
}
public static BluetoothUuid FromShortId(ushort shortId)
{
byte[] array = BluetoothBase.ToByteArray();
BitConverter.GetBytes(shortId).CopyTo(array, 0);
return new Guid(array);
}
public static ushort? TryGetShortId(Guid uuid)
{
byte[] array = uuid.ToByteArray();
byte[] array2 = BluetoothBase.ToByteArray();
bool flag = true;
for (int i = 4; i < 16; i++)
{
if (array[i] != array2[i])
{
flag = false;
break;
}
}
if (!flag)
{
return null;
}
return BitConverter.ToUInt16(array, 0);
}
public static BluetoothUuid FromId(string uuidName)
{
if (uuidName.StartsWith("org.bluetooth.service"))
{
return GattServiceUuids.FromBluetoothUti(uuidName);
}
if (uuidName.StartsWith("org.bluetooth.characteristic"))
{
return GattCharacteristicUuids.FromBluetoothUti(uuidName);
}
if (uuidName.StartsWith("org.bluetooth.descriptor"))
{
return GattDescriptorUuids.FromBluetoothUti(uuidName);
}
return default(BluetoothUuid);
}
public static BluetoothUuid GetService(string name)
{
if (Guid.TryParse(name, out var result))
{
return result;
}
if (ushort.TryParse(name, out var result2))
{
return FromShortId(result2);
}
return GattServiceUuids.FromBluetoothUti(name);
}
public static BluetoothUuid GetCharacteristic(string name)
{
if (Guid.TryParse(name, out var result))
{
return result;
}
if (ushort.TryParse(name, out var result2))
{
return FromShortId(result2);
}
return GattCharacteristicUuids.FromBluetoothUti(name);
}
public static BluetoothUuid GetDescriptor(string name)
{
if (Guid.TryParse(name, out var result))
{
return result;
}
if (ushort.TryParse(name, out var result2))
{
return FromShortId(result2);
}
return GattDescriptorUuids.FromBluetoothUti(name);
}
}
[Flags]
internal enum ClientCharacteristicDescriptorValue
{
None = 0,
Notify = 1,
Indicate = 2
}
[DebuggerDisplay("{Uuid} (Characteristic)")]
public sealed class GattCharacteristic
{
private readonly GattCharacteristic _characteristic;
public GattService Service { get; private set; }
public BluetoothUuid Uuid => GetUuid();
public GattCharacteristicProperties Properties => GetProperties();
public string UserDescription => GetUserDescription();
public byte[] Value => PlatformGetValue();
private event EventHandler<GattCharacteristicValueChangedEventArgs> characteristicValueChanged;
public event EventHandler<GattCharacteristicValueChangedEventArgs> CharacteristicValueChanged
{
add
{
characteristicValueChanged += value;
AddCharacteristicValueChanged();
}
remove
{
characteristicValueChanged -= value;
RemoveCharacteristicValueChanged();
}
}
internal GattCharacteristic(GattService service)
{
Service = service;
}
private string GetManualUserDescription()
{
GattDescriptor result = GetDescriptorAsync(GattDescriptorUuids.CharacteristicUserDescription).Result;
if (result != null)
{
byte[] result2 = result.ReadValueAsync().Result;
return Encoding.UTF8.GetString(result2);
}
return string.Empty;
}
public Task<byte[]> ReadValueAsync()
{
return PlatformReadValue();
}
public Task WriteValueWithResponseAsync(byte[] value)
{
ThrowOnInvalidValue(value);
return PlatformWriteValue(value, requireResponse: true);
}
public Task WriteValueWithoutResponseAsync(byte[] value)
{
ThrowOnInvalidValue(value);
return PlatformWriteValue(value, requireResponse: false);
}
private void ThrowOnInvalidValue(byte[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (value.Length > 512)
{
throw new ArgumentOutOfRangeException("value", "Attribute value cannot be longer than 512 bytes");
}
}
public Task<GattDescriptor> GetDescriptorAsync(BluetoothUuid descriptor)
{
return PlatformGetDescriptor(descriptor);
}
public Task<IReadOnlyList<GattDescriptor>> GetDescriptorsAsync()
{
return PlatformGetDescriptors();
}
private void OnCharacteristicValueChanged(GattCharacteristicValueChangedEventArgs args)
{
this.characteristicValueChanged?.Invoke(this, args);
}
public Task StartNotificationsAsync()
{
return PlatformStartNotifications();
}
public Task StopNotificationsAsync()
{
return PlatformStopNotifications();
}
internal GattCharacteristic(GattService service, GattCharacteristic characteristic)
: this(service)
{
_characteristic = characteristic;
}
public static implicit operator GattCharacteristic(GattCharacteristic characteristic)
{
return characteristic._characteristic;
}
private BluetoothUuid GetUuid()
{
return _characteristic.Uuid;
}
private string GetUserDescription()
{
return _characteristic.UserDescription;
}
private GattCharacteristicProperties GetProperties()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected I4, but got Unknown
return (GattCharacteristicProperties)_characteristic.CharacteristicProperties;
}
private async Task<GattDescriptor> PlatformGetDescriptor(Guid descriptor)
{
TaskAwaiter<GattDescriptorsResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattDescriptorsResult>(_characteristic.GetDescriptorsForUuidAsync(descriptor));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattDescriptorsResult> taskAwaiter2 = default(TaskAwaiter<GattDescriptorsResult>);
taskAwaiter = taskAwaiter2;
}
GattDescriptorsResult result = taskAwaiter.GetResult();
GattDescriptorsResult val = result;
if ((int)val.Status == 0 && val.Descriptors.Count > 0)
{
return new GattDescriptor(this, val.Descriptors[0]);
}
return null;
}
private async Task<IReadOnlyList<GattDescriptor>> PlatformGetDescriptors()
{
List<GattDescriptor> descriptors = new List<GattDescriptor>();
TaskAwaiter<GattDescriptorsResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattDescriptorsResult>(_characteristic.GetDescriptorsAsync());
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattDescriptorsResult> taskAwaiter2 = default(TaskAwaiter<GattDescriptorsResult>);
taskAwaiter = taskAwaiter2;
}
GattDescriptorsResult result = taskAwaiter.GetResult();
GattDescriptorsResult val = result;
if ((int)val.Status == 0)
{
foreach (GattDescriptor descriptor in val.Descriptors)
{
descriptors.Add(new GattDescriptor(this, descriptor));
}
}
return descriptors;
}
private byte[] PlatformGetValue()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
Task<GattReadResult> task = WindowsRuntimeSystemExtensions.AsTask<GattReadResult>(_characteristic.ReadValueAsync((BluetoothCacheMode)0));
task.Wait();
GattReadResult result = task.Result;
if ((int)result.Status == 0)
{
return WindowsRuntimeBufferExtensions.ToArray(result.Value);
}
return null;
}
private async Task<byte[]> PlatformReadValue()
{
GattReadResult val = await WindowsRuntimeSystemExtensions.AsTask<GattReadResult>(_characteristic.ReadValueAsync((BluetoothCacheMode)1)).ConfigureAwait(continueOnCapturedContext: false);
if ((int)val.Status == 0)
{
return WindowsRuntimeBufferExtensions.ToArray(val.Value);
}
return null;
}
private async Task PlatformWriteValue(byte[] value, bool requireResponse)
{
TaskAwaiter<GattCommunicationStatus> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattCommunicationStatus>(_characteristic.WriteValueAsync(WindowsRuntimeBufferExtensions.AsBuffer(value), (GattWriteOption)((!requireResponse) ? 1 : 0)));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattCommunicationStatus> taskAwaiter2 = default(TaskAwaiter<GattCommunicationStatus>);
taskAwaiter = taskAwaiter2;
}
taskAwaiter.GetResult();
}
private void AddCharacteristicValueChanged()
{
_characteristic.ValueChanged += Characteristic_ValueChanged;
}
private void Characteristic_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
{
OnCharacteristicValueChanged(new GattCharacteristicValueChangedEventArgs(WindowsRuntimeBufferExtensions.ToArray(args.CharacteristicValue)));
}
private void RemoveCharacteristicValueChanged()
{
_characteristic.ValueChanged -= Characteristic_ValueChanged;
}
private async Task PlatformStartNotifications()
{
GattClientCharacteristicConfigurationDescriptorValue val;
if (((Enum)_characteristic.CharacteristicProperties).HasFlag((Enum)(object)(GattCharacteristicProperties)16))
{
val = (GattClientCharacteristicConfigurationDescriptorValue)1;
}
else
{
if (!((Enum)_characteristic.CharacteristicProperties).HasFlag((Enum)(object)(GattCharacteristicProperties)32))
{
return;
}
val = (GattClientCharacteristicConfigurationDescriptorValue)2;
}
try
{
TaskAwaiter<GattCommunicationStatus> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattCommunicationStatus>(_characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(val));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattCommunicationStatus> taskAwaiter2 = default(TaskAwaiter<GattCommunicationStatus>);
taskAwaiter = taskAwaiter2;
}
taskAwaiter.GetResult();
}
catch (UnauthorizedAccessException)
{
}
}
private async Task PlatformStopNotifications()
{
try
{
TaskAwaiter<GattCommunicationStatus> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattCommunicationStatus>(_characteristic.WriteClientCharacteristicConfigurationDescriptorAsync((GattClientCharacteristicConfigurationDescriptorValue)0));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattCommunicationStatus> taskAwaiter2 = default(TaskAwaiter<GattCommunicationStatus>);
taskAwaiter = taskAwaiter2;
}
taskAwaiter.GetResult();
}
catch
{
throw new NotSupportedException();
}
}
}
public sealed class GattCharacteristicValueChangedEventArgs : EventArgs
{
public byte[] Value { get; private set; }
internal GattCharacteristicValueChangedEventArgs(byte[] newValue)
{
Value = newValue;
}
}
[Flags]
public enum GattCharacteristicProperties
{
None = 0,
Broadcast = 1,
Read = 2,
WriteWithoutResponse = 4,
Write = 8,
Notify = 0x10,
Indicate = 0x20,
AuthenticatedSignedWrites = 0x40,
ExtendedProperties = 0x80,
ReliableWrites = 0x100,
WriteableAuxiliaries = 0x200
}
[BluetoothUti("org.bluetooth.characteristic")]
public static class GattCharacteristicUuids
{
internal const string Namespace = "org.bluetooth.characteristic";
[BluetoothUti("aerobic_heart_rate_lower_limit")]
public static readonly BluetoothUuid AerobicHeartRateLowerLimit = (ushort)10878;
[BluetoothUti("aerobic_heart_rate_upper_limit")]
public static readonly BluetoothUuid AerobicHeartRateUpperLimit = (ushort)10884;
[BluetoothUti("aerobic_threshold")]
public static readonly BluetoothUuid AerobicThreshold = (ushort)10879;
[BluetoothUti("age")]
public static readonly BluetoothUuid Age = (ushort)10880;
[BluetoothUti("aggregate")]
public static readonly BluetoothUuid Aggregate = (ushort)10842;
[BluetoothUti("alert_category_id")]
public static readonly BluetoothUuid AlertCategoryId = (ushort)10819;
[BluetoothUti("alert_category_id_bit_mask")]
public static readonly BluetoothUuid AlertCategoryIdBitMask = (ushort)10818;
[BluetoothUti("alert_level")]
public static readonly BluetoothUuid AlertLevel = (ushort)10758;
[BluetoothUti("alert_notification_control_point")]
public static readonly BluetoothUuid AlertNotificationControlPoint = (ushort)10820;
[BluetoothUti("alert_status")]
public static readonly BluetoothUuid AlertStatus = (ushort)10815;
[BluetoothUti("altitude")]
public static readonly BluetoothUuid Altitude = (ushort)10931;
[BluetoothUti("anaerobic_heart_rate_lower_limit")]
public static readonly BluetoothUuid AnaerobicHeartRateLowerLimit = (ushort)10881;
[BluetoothUti("anaerobic_heart_rate_upper_limit")]
public static readonly BluetoothUuid AnaerobicHeartRateUpperLimit = (ushort)10882;
[BluetoothUti("anaerobic_threshold")]
public static readonly BluetoothUuid AnaerobicThreshold = (ushort)10883;
[BluetoothUti("analog")]
public static readonly BluetoothUuid Analog = (ushort)10840;
[BluetoothUti("analog_output")]
public static readonly BluetoothUuid AnalogOutput = (ushort)10841;
[BluetoothUti("apparent_wind_direction")]
public static readonly BluetoothUuid ApparentWindDirection = (ushort)10867;
[BluetoothUti("apparent_wind_speed")]
public static readonly BluetoothUuid ApparentWindSpeed = (ushort)10866;
[BluetoothUti("gap.appearance")]
public static readonly BluetoothUuid Appearance = (ushort)10753;
[BluetoothUti("barometric_pressure_trend")]
public static readonly BluetoothUuid BarometricPressureTrend = (ushort)10915;
[BluetoothUti("battery_level")]
public static readonly BluetoothUuid BatteryLevel = (ushort)10777;
[BluetoothUti("battery_level_state")]
public static readonly BluetoothUuid BatteryLevelState = (ushort)10779;
[BluetoothUti("battery_power_state")]
public static readonly BluetoothUuid BatteryPowerState = (ushort)10778;
[BluetoothUti("blood_pressure_feature")]
public static readonly BluetoothUuid BloodPressureFeature = (ushort)10825;
[BluetoothUti("blood_pressure_measurement")]
public static readonly BluetoothUuid BloodPressureMeasurement = (ushort)10805;
[BluetoothUti("body_composition_feature")]
public static readonly BluetoothUuid BodyCompositionFeature = (ushort)10907;
[BluetoothUti("body_composition_measurement")]
public static readonly BluetoothUuid BodyCompositionMeasurement = (ushort)10908;
[BluetoothUti("body_sensor_location")]
public static readonly BluetoothUuid BodySensorLocation = (ushort)10808;
[BluetoothUti("bond_management_control_point")]
public static readonly BluetoothUuid BondManagementControlPoint = (ushort)10916;
[BluetoothUti("bond_management_feature")]
public static readonly BluetoothUuid BondManagementFeatures = (ushort)10917;
[BluetoothUti("boot_keyboard_input_report")]
public static readonly BluetoothUuid BootKeyboardInputReport = (ushort)10786;
[BluetoothUti("boot_keyboard_output_report")]
public static readonly BluetoothUuid BootKeyboardOutputReport = (ushort)10802;
[BluetoothUti("boot_mouse_input_report")]
public static readonly BluetoothUuid BootMouseInputReport = (ushort)10803;
public static readonly BluetoothUuid BssControlPoint = (ushort)11051;
public static readonly BluetoothUuid BssResponse = (ushort)11052;
[BluetoothUti("gap.central_address_resolution")]
public static readonly BluetoothUuid CentralAddressResolution = (ushort)10918;
[BluetoothUti("cgm_feature")]
public static readonly BluetoothUuid CgmFeature = (ushort)10920;
[BluetoothUti("cgm_measurement")]
public static readonly BluetoothUuid CgmMeasurement = (ushort)10919;
[BluetoothUti("cgm_session_run_time")]
public static readonly BluetoothUuid CgmSessionRunTime = (ushort)10923;
[BluetoothUti("cgm_session_start_time")]
public static readonly BluetoothUuid CgmSessionStartTime = (ushort)10922;
[BluetoothUti("cgm_specific_ops_control_point")]
public static readonly BluetoothUuid CgmSpecificOpsControlPoint = (ushort)10924;
[BluetoothUti("cgm_status")]
public static readonly BluetoothUuid CgmStatus = (ushort)10921;
public static readonly BluetoothUuid ClientSupportedFeatures = (ushort)11049;
[BluetoothUti("cross_trainer_data")]
public static readonly BluetoothUuid CrossTrainerData = (ushort)10958;
[BluetoothUti("csc_feature")]
public static readonly BluetoothUuid CscFeature = (ushort)10844;
[BluetoothUti("csc_measurement")]
public static readonly BluetoothUuid CscMeasurement = (ushort)10843;
[BluetoothUti("current_time")]
public static readonly BluetoothUuid CurrentTime = (ushort)10795;
[BluetoothUti("cycling_power_control_point")]
public static readonly BluetoothUuid CyclingPowerControlPoint = (ushort)10854;
[BluetoothUti("cycling_power_feature")]
public static readonly BluetoothUuid CyclingPowerFeature = (ushort)10853;
[BluetoothUti("cycling_power_measurement")]
public static readonly BluetoothUuid CyclingPowerMeasurement = (ushort)10851;
[BluetoothUti("cycling_power_vector")]
public static readonly BluetoothUuid CyclingPowerVector = (ushort)10852;
[BluetoothUti("database_change_increment")]
public static readonly BluetoothUuid DatabaseChangeIncrement = (ushort)10905;
[BluetoothUti("database_hash")]
public static readonly BluetoothUuid DatabaseHash = (ushort)11050;
[BluetoothUti("date_of_birth")]
public static readonly BluetoothUuid DateOfBirth = (ushort)10885;
[BluetoothUti("date_of_threshold_assessment")]
public static readonly BluetoothUuid DateOfThresholdAssessment = (ushort)10886;
[BluetoothUti("date_time")]
public static readonly BluetoothUuid DateTime = (ushort)10760;
[BluetoothUti("date_utc")]
public static readonly BluetoothUuid DateUtc = (ushort)10989;
[BluetoothUti("day_date_time")]
public static readonly BluetoothUuid DayDateTime = (ushort)10762;
[BluetoothUti("day_of_week")]
public static readonly BluetoothUuid DayOfWeek = (ushort)10761;
[BluetoothUti("descriptor_value_changed")]
public static readonly BluetoothUuid DescriptorValueChanged = (ushort)10877;
[BluetoothUti("gap.device_name")]
public static readonly BluetoothUuid DeviceName = (ushort)10752;
[BluetoothUti("dew_point")]
public static readonly BluetoothUuid DewPoint = (ushort)10875;
[BluetoothUti("digital")]
public static readonly BluetoothUuid Digital = (ushort)10838;
[BluetoothUti("digital_output")]
public static readonly BluetoothUuid DigitalOutput = (ushort)10839;
[BluetoothUti("dst_offset")]
public static readonly BluetoothUuid DstOffset = (ushort)10765;
[BluetoothUti("elevation")]
public static readonly BluetoothUuid Elevation = (ushort)10860;
[BluetoothUti("email_address")]
public static readonly BluetoothUuid EmailAddress = (ushort)10887;
public static readonly BluetoothUuid EmergencyId = (ushort)11053;
public static readonly BluetoothUuid EmergencyText = (ushort)11054;
[BluetoothUti("exact_time_100")]
public static readonly BluetoothUuid ExactTime100 = (ushort)10763;
[BluetoothUti("exact_time_256")]
public static readonly BluetoothUuid ExactTime256 = (ushort)10764;
[BluetoothUti("fat_burn_heart_rate_lower_limit")]
public static readonly BluetoothUuid FatBurnHeartRateLowerLimit = (ushort)10888;
[BluetoothUti("fat_burn_heart_rate_upper_limit")]
public static readonly BluetoothUuid FatBurnHeartRateUpperLimit = (ushort)10889;
[BluetoothUti("firmware_revision_string")]
public static readonly BluetoothUuid FirmwareRevisionString = (ushort)10790;
[BluetoothUti("first_name")]
public static readonly BluetoothUuid FirstName = (ushort)10890;
[BluetoothUti("fitness_machine_control_point")]
public static readonly BluetoothUuid FitnessMachineControlPoint = (ushort)10969;
[BluetoothUti("fitness_machine_feature")]
public static readonly BluetoothUuid FitnessMachineFeature = (ushort)10956;
[BluetoothUti("fitness_machine_status")]
public static readonly BluetoothUuid FitnessMachineStatus = (ushort)10970;
[BluetoothUti("five_zone_heart_rate_limits")]
public static readonly BluetoothUuid FiveZoneHeartRateLimits = (ushort)10891;
[BluetoothUti("floor_number")]
public static readonly BluetoothUuid FloorNumber = (ushort)10930;
[BluetoothUti("gender")]
public static readonly BluetoothUuid Gender = (ushort)10892;
[BluetoothUti("glucose_feature")]
public static readonly BluetoothUuid GlucoseFeature = (ushort)10833;
[BluetoothUti("glucose_measurement")]
public static readonly BluetoothUuid GlucoseMeasurement = (ushort)10776;
[BluetoothUti("glucose_measurement_context")]
public static readonly BluetoothUuid GlucoseMeasurementContext = (ushort)10804;
[BluetoothUti("gust_factor")]
public static readonly BluetoothUuid GustFactor = (ushort)10868;
[BluetoothUti("hardware_revision_string")]
public static readonly BluetoothUuid HardwareRevisionString = (ushort)10791;
[BluetoothUti("heart_rate_control_point")]
public static readonly BluetoothUuid HeartRateControlPoint = (ushort)10809;
[BluetoothUti("heart_rate_max")]
public static readonly BluetoothUuid HeartRateMax = (ushort)10893;
[BluetoothUti("heart_rate_measurement")]
public static readonly BluetoothUuid HeartRateMeasurement = (ushort)10807;
[BluetoothUti("heat_index")]
public static readonly BluetoothUuid HeatIndex = (ushort)10874;
[BluetoothUti("height")]
public static readonly BluetoothUuid Height = (ushort)10894;
[BluetoothUti("hid_control_point")]
public static readonly BluetoothUuid HidControlPoint = (ushort)10828;
[BluetoothUti("hid_information")]
public static readonly BluetoothUuid HidInformation = (ushort)10826;
[BluetoothUti("hip_circumference")]
public static readonly BluetoothUuid HipCircumference = (ushort)10895;
[BluetoothUti("http_control_point")]
public static readonly BluetoothUuid HttpControlPoint = (ushort)10938;
[BluetoothUti("http_entity_body")]
public static readonly BluetoothUuid HttpEntityBody = (ushort)10937;
[BluetoothUti("http_headers")]
public static readonly BluetoothUuid HttpHeaders = (ushort)10935;
[BluetoothUti("http_status_code")]
public static readonly BluetoothUuid HttpStatusCode = (ushort)10936;
[BluetoothUti("https_security")]
public static readonly BluetoothUuid HttpsSecurity = (ushort)10939;
[BluetoothUti("humidity")]
public static readonly BluetoothUuid Humidity = (ushort)10863;
[BluetoothUti("idd_annunciation_status")]
public static readonly BluetoothUuid IddAnnunciationStatus = (ushort)11042;
[BluetoothUti("idd_command_control_point")]
public static readonly BluetoothUuid IddCommandControlPoint = (ushort)11045;
[BluetoothUti("idd_command_data")]
public static readonly BluetoothUuid IddCommandData = (ushort)11046;
[BluetoothUti("idd_features")]
public static readonly BluetoothUuid IddFeatures = (ushort)11043;
[BluetoothUti("idd_history_data")]
public static readonly BluetoothUuid IddHistoryData = (ushort)11048;
[BluetoothUti("idd_record_access_control_point")]
public static readonly BluetoothUuid IddRecordAccessControlPoint = (ushort)11047;
[BluetoothUti("idd_status")]
public static readonly BluetoothUuid IddStatus = (ushort)11041;
[BluetoothUti("idd_status_changed")]
public static readonly BluetoothUuid IddStatusChanged = (ushort)11040;
[BluetoothUti("idd_status_reader_control_point")]
public static readonly BluetoothUuid IddStatusReaderControlPoint = (ushort)11044;
[BluetoothUti("indoor_bike_data")]
public static readonly BluetoothUuid IndoorBikeData = (ushort)10962;
[BluetoothUti("indoor_positioning_configuration")]
public static readonly BluetoothUuid IndoorPositioningConfiguration = (ushort)10925;
[BluetoothUti("intermediate_cuff_pressure")]
public static readonly BluetoothUuid IntermediateCuffPressure = (ushort)10806;
[BluetoothUti("intermediate_temperature")]
public static readonly BluetoothUuid IntermediateTemperature = (ushort)10782;
[BluetoothUti("irradiance")]
public static readonly BluetoothUuid Irradiance = (ushort)10871;
[BluetoothUti("language")]
public static readonly BluetoothUuid Language = (ushort)10914;
[BluetoothUti("last_name")]
public static readonly BluetoothUuid LastName = (ushort)10896;
[BluetoothUti("latitude")]
public static readonly BluetoothUuid Latitude = (ushort)10926;
[BluetoothUti("ln_control_point")]
public static readonly BluetoothUuid LNControlPoint = (ushort)10859;
[BluetoothUti("ln_feature")]
public static readonly BluetoothUuid LNFeature = (ushort)10858;
[BluetoothUti("local_east_coordinate")]
public static readonly BluetoothUuid LocalEastCoordinate = (ushort)10929;
[BluetoothUti("local_north_coordinate")]
public static readonly BluetoothUuid LocalNorthCoordinate = (ushort)10928;
[BluetoothUti("local_time_information")]
public static readonly BluetoothUuid LocalTimeInformation = (ushort)10767;
[BluetoothUti("location_and_speed")]
public static readonly BluetoothUuid LocationAndSpeed = (ushort)10855;
[BluetoothUti("location_name")]
public static readonly BluetoothUuid LocationName = (ushort)10933;
[BluetoothUti("longitude")]
public static readonly BluetoothUuid Longitude = (ushort)10927;
[BluetoothUti("magnetic_declination")]
public static readonly BluetoothUuid MagneticDeclination = (ushort)10796;
[BluetoothUti("Magnetic_flux_density_2D")]
public static readonly BluetoothUuid MagneticFluxDensity2D = (ushort)10912;
[BluetoothUti("Magnetic_flux_density_3D")]
public static readonly BluetoothUuid MagneticFluxDensity3D = (ushort)10913;
[BluetoothUti("manufacturer_name_string")]
public static readonly BluetoothUuid ManufacturerNameString = (ushort)10793;
[BluetoothUti("maximum_recommended_heart_rate")]
public static readonly BluetoothUuid MaximumRecommendedHeartRate = (ushort)10897;
[BluetoothUti("measurement_interval")]
public static readonly BluetoothUuid MeasurementInterval = (ushort)10785;
[BluetoothUti("model_number_string")]
public static readonly BluetoothUuid ModelNumberString = (ushort)10788;
[BluetoothUti("navigation")]
public static readonly BluetoothUuid Navigation = (ushort)10856;
[BluetoothUti("network_availability")]
public static readonly BluetoothUuid NetworkAvailability = (ushort)10814;
[BluetoothUti("new_alert")]
public static readonly BluetoothUuid NewAlert = (ushort)10822;
[BluetoothUti("object_action_control_point")]
public static readonly BluetoothUuid ObjectActionControlPoint = (ushort)10949;
[BluetoothUti("object_changed")]
public static readonly BluetoothUuid ObjectChanged = (ushort)10952;
[BluetoothUti("object_first_created")]
public static readonly BluetoothUuid ObjectFirstCreated = (ushort)10945;
[BluetoothUti("object_id")]
public static readonly BluetoothUuid ObjectID = (ushort)10947;
[BluetoothUti("object_last_modified")]
public static readonly BluetoothUuid ObjectLastModified = (ushort)10946;
[BluetoothUti("object_list_control_point")]
public static readonly BluetoothUuid ObjectListControlPoint = (ushort)10950;
[BluetoothUti("object_list_filter")]
public static readonly BluetoothUuid ObjectListFilter = (ushort)10951;
[BluetoothUti("object_name")]
public static readonly BluetoothUuid ObjectName = (ushort)10942;
[BluetoothUti("object_properties")]
public static readonly BluetoothUuid ObjectProperties = (ushort)10948;
[BluetoothUti("object_size")]
public static readonly BluetoothUuid ObjectSize = (ushort)10944;
[BluetoothUti("object_type")]
public static readonly BluetoothUuid ObjectType = (ushort)10943;
[BluetoothUti("ots_feature")]
public static readonly BluetoothUuid OtsFeature = (ushort)10941;
[BluetoothUti("gap.peripheral_preferred_connection_parameters")]
public static readonly BluetoothUuid PeripheralPreferredConnectionParameters = (ushort)10756;
[BluetoothUti("gap.peripheral_privacy_flag")]
public static readonly BluetoothUuid PeripheralPrivacyFlag = (ushort)10754;
[BluetoothUti("plx_spot_check_measurement")]
public static readonly BluetoothUuid PlxSpotCheckMeasurement = (ushort)10846;
[BluetoothUti("plx_continuous_measurement")]
public static readonly BluetoothUuid PlxContinuousMeasurement = (ushort)10847;
[BluetoothUti("plx_features")]
public static readonly BluetoothUuid PlxFeatures = (ushort)10848;
[BluetoothUti("pollen_concentration")]
public static readonly BluetoothUuid PollenConcentration = (ushort)10869;
[BluetoothUti("position_quality")]
public static readonly BluetoothUuid PositionQuality = (ushort)10857;
[BluetoothUti("pressure")]
public static readonly BluetoothUuid Pressure = (ushort)10861;
[BluetoothUti("rainfall")]
public static readonly BluetoothUuid Rainfall = (ushort)10872;
[BluetoothUti("gap.reconnection_address")]
public static readonly BluetoothUuid ReconnectionAddress = (ushort)10755;
[BluetoothUti("reference_time_information")]
public static readonly BluetoothUuid ReferenceTimeInformation = (ushort)10772;
[BluetoothUti("ieee_11073-20601_regulatoryertification_data_list")]
public static readonly BluetoothUuid RegulatoryCertificationDataList = (ushort)10794;
[BluetoothUti("sensor_location")]
public static readonly BluetoothUuid SensorLocation = (ushort)10845;
[BluetoothUti("server_supported_features")]
public static readonly BluetoothUuid ServerSupportedFeatures = (ushort)11066;
[BluetoothUti("gap.service_changed")]
public static readonly BluetoothUuid ServiceChanged = (ushort)10757;
[BluetoothUti("tempurature")]
public static readonly BluetoothUuid Tempurature = (ushort)10862;
[BluetoothUti("tempurature_measurement")]
public static readonly BluetoothUuid TempuratureMeasurement = (ushort)10780;
[BluetoothUti("tempurature_type")]
public static readonly BluetoothUuid TempuratureType = (ushort)10781;
[BluetoothUti("time_accuracy")]
public static readonly BluetoothUuid TimeAccuracy = (ushort)10770;
[BluetoothUti("time_source")]
public static readonly BluetoothUuid TimeSource = (ushort)10771;
[BluetoothUti("time_update_control_point")]
public static readonly BluetoothUuid TimeUpdateControlPoint = (ushort)10774;
[BluetoothUti("time_update_state")]
public static readonly BluetoothUuid TimeUpdateState = (ushort)10775;
[BluetoothUti("time_with_dst")]
public static readonly BluetoothUuid TimeWithDst = (ushort)10769;
[BluetoothUti("time_zone")]
public static readonly BluetoothUuid TimeZone = (ushort)10766;
[BluetoothUti("true_wind_direction")]
public static readonly BluetoothUuid TrueWindDirection = (ushort)10865;
[BluetoothUti("true_wind_speed")]
public static readonly BluetoothUuid TrueWindSpeed = (ushort)10864;
[BluetoothUti("uv_index")]
public static readonly BluetoothUuid UVIndex = (ushort)10870;
[BluetoothUti("wind_chill")]
public static readonly BluetoothUuid WindChill = (ushort)10873;
public static BluetoothUuid FromBluetoothUti(string bluetoothUti)
{
string text = bluetoothUti.ToLower();
if (text.StartsWith("org.bluetooth.characteristic"))
{
text = text.Replace("org.bluetooth.characteristic.", string.Empty);
}
FieldInfo[] fields = typeof(GattCharacteristicUuids).GetFields(BindingFlags.Static | BindingFlags.Public);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
Attribute customAttribute = fieldInfo.GetCustomAttribute(typeof(BluetoothUtiAttribute));
if (customAttribute != null && ((BluetoothUtiAttribute)customAttribute).Uti == text)
{
return (BluetoothUuid)fieldInfo.GetValue(null);
}
}
return default(BluetoothUuid);
}
public static string GetCharacteristicName(BluetoothUuid uuid, bool includeNamespace = false)
{
ushort? num = BluetoothUuid.TryGetShortId(uuid);
if (num.HasValue && (num.Value & 0xF200) == 8704)
{
FieldInfo[] fields = typeof(GattCharacteristicUuids).GetFields(BindingFlags.Static | BindingFlags.Public);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
if ((BluetoothUuid)fieldInfo.GetValue(null) == uuid)
{
Attribute customAttribute = fieldInfo.GetCustomAttribute(typeof(BluetoothUtiAttribute));
if (customAttribute != null)
{
return (includeNamespace ? "org.bluetooth.characteristic." : string.Empty) + ((BluetoothUtiAttribute)customAttribute).Uti;
}
return string.Empty;
}
}
}
return string.Empty;
}
}
[DebuggerDisplay("{Uuid} (Descriptor)")]
public sealed class GattDescriptor
{
private GattDescriptor _descriptor;
public GattCharacteristic Characteristic { get; private set; }
public BluetoothUuid Uuid => GetUuid();
public byte[] Value => PlatformGetValue();
internal GattDescriptor(GattCharacteristic characteristic)
{
Characteristic = characteristic;
}
public Task<byte[]> ReadValueAsync()
{
return PlatformReadValue();
}
public Task WriteValueAsync(byte[] value)
{
return PlatformWriteValue(value);
}
internal GattDescriptor(GattCharacteristic characteristic, GattDescriptor descriptor)
: this(characteristic)
{
_descriptor = descriptor;
}
public static implicit operator GattDescriptor(GattDescriptor descriptor)
{
return descriptor._descriptor;
}
private Guid GetUuid()
{
return _descriptor.Uuid;
}
private byte[] PlatformGetValue()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
GattReadResult results = _descriptor.ReadValueAsync((BluetoothCacheMode)0).GetResults();
if ((int)results.Status == 0)
{
return WindowsRuntimeBufferExtensions.ToArray(results.Value);
}
return null;
}
private async Task<byte[]> PlatformReadValue()
{
GattReadResult val = await WindowsRuntimeSystemExtensions.AsTask<GattReadResult>(_descriptor.ReadValueAsync((BluetoothCacheMode)1)).ConfigureAwait(continueOnCapturedContext: false);
if ((int)val.Status == 0)
{
return WindowsRuntimeBufferExtensions.ToArray(val.Value);
}
return null;
}
private async Task PlatformWriteValue(byte[] value)
{
TaskAwaiter<GattCommunicationStatus> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattCommunicationStatus>(_descriptor.WriteValueAsync(WindowsRuntimeBufferExtensions.AsBuffer(value)));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattCommunicationStatus> taskAwaiter2 = default(TaskAwaiter<GattCommunicationStatus>);
taskAwaiter = taskAwaiter2;
}
taskAwaiter.GetResult();
}
}
[BluetoothUti("org.bluetooth.descriptor")]
public static class GattDescriptorUuids
{
internal const string Namespace = "org.bluetooth.descriptor";
[BluetoothUti("gatt.characteristic_aggregate_format")]
public static readonly BluetoothUuid CharacteristicAggregateFormat = (ushort)10501;
[BluetoothUti("gatt.characteristic_extended_properties")]
public static readonly BluetoothUuid CharacteristicExtendedProperties = (ushort)10496;
[BluetoothUti("gatt.characteristic_presentation_format")]
public static readonly BluetoothUuid CharacteristicPresentationFormat = (ushort)10500;
[BluetoothUti("gatt.characteristic_user_description")]
public static readonly BluetoothUuid CharacteristicUserDescription = (ushort)10497;
[BluetoothUti("gatt.client_characteristic_configuration")]
public static readonly BluetoothUuid ClientCharacteristicConfiguration = (ushort)10498;
[BluetoothUti("es_configuration")]
public static readonly BluetoothUuid EnvironmentalSensingConfiguration = (ushort)10507;
[BluetoothUti("es_measurement")]
public static readonly BluetoothUuid EnvironmentalSensingMeasurement = (ushort)10508;
[BluetoothUti("es_trigger_setting")]
public static readonly BluetoothUuid EnvironmentalSensingTriggerSetting = (ushort)10509;
[BluetoothUti("external_report_reference")]
public static readonly BluetoothUuid EnvironmentalSensingReportReference = (ushort)10503;
[BluetoothUti("number_of_digitals")]
public static readonly BluetoothUuid NumberOfDigitals = (ushort)10505;
[BluetoothUti("report_reference")]
public static readonly BluetoothUuid ReportReference = (ushort)10504;
[BluetoothUti("gatt.server_characteristic_configuration")]
public static readonly BluetoothUuid ServerCharacteristicConfiguration = (ushort)10499;
[BluetoothUti("time_trigger_setting")]
public static readonly BluetoothUuid TimeTriggerSetting = (ushort)10510;
[BluetoothUti("valid_range")]
public static readonly BluetoothUuid ValidRange = (ushort)10502;
[BluetoothUti("value_trigger_setting")]
public static readonly BluetoothUuid ValueTriggerSetting = (ushort)10506;
public static BluetoothUuid FromBluetoothUti(string bluetoothUti)
{
string text = bluetoothUti.ToLower();
if (text.StartsWith("org.bluetooth.descriptor"))
{
text = text.Replace("org.bluetooth.descriptor.", string.Empty);
}
FieldInfo[] fields = typeof(GattDescriptorUuids).GetFields(BindingFlags.Static | BindingFlags.Public);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
Attribute customAttribute = fieldInfo.GetCustomAttribute(typeof(BluetoothUtiAttribute));
if (customAttribute != null && ((BluetoothUtiAttribute)customAttribute).Uti == text)
{
return (BluetoothUuid)fieldInfo.GetValue(null);
}
}
return default(BluetoothUuid);
}
public static string GetDescriptorName(BluetoothUuid uuid, bool includeNamespace = false)
{
ushort? num = BluetoothUuid.TryGetShortId(uuid);
if (num.HasValue && (num.Value & 0xFF00) == 10496)
{
FieldInfo[] fields = typeof(GattDescriptorUuids).GetFields(BindingFlags.Static | BindingFlags.Public);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
if ((BluetoothUuid)fieldInfo.GetValue(null) == uuid)
{
Attribute customAttribute = fieldInfo.GetCustomAttribute(typeof(BluetoothUtiAttribute));
if (customAttribute != null)
{
return (includeNamespace ? "org.bluetooth.descriptor." : string.Empty) + ((BluetoothUtiAttribute)customAttribute).Uti;
}
return string.Empty;
}
}
}
return string.Empty;
}
}
[DebuggerDisplay("{Uuid} (Service)")]
public sealed class GattService
{
private readonly GattDeviceService _service;
private readonly bool _isPrimary;
public BluetoothDevice Device { get; private set; }
public BluetoothUuid Uuid => GetUuid();
public bool IsPrimary => GetIsPrimary();
internal GattService(BluetoothDevice device)
{
Device = device;
}
public Task<GattCharacteristic> GetCharacteristicAsync(BluetoothUuid characteristic)
{
return PlatformGetCharacteristic(characteristic);
}
public Task<IReadOnlyList<GattCharacteristic>> GetCharacteristicsAsync()
{
return PlatformGetCharacteristics();
}
public Task<GattService> GetIncludedServiceAsync(BluetoothUuid service)
{
return PlatformGetIncludedServiceAsync(service);
}
public Task<IReadOnlyList<GattService>> GetIncludedServicesAsync()
{
return PlatformGetIncludedServicesAsync();
}
internal GattService(BluetoothDevice device, GattDeviceService service, bool isPrimary)
: this(device)
{
_service = service;
_isPrimary = isPrimary;
device.AddDisposableObject(this, (IDisposable)service);
}
public static implicit operator GattDeviceService(GattService service)
{
return service._service;
}
public static implicit operator GattService(GattDeviceService service)
{
return new GattService(service.Device, service, isPrimary: false);
}
private async Task<bool> OpenAsync()
{
TaskAwaiter<GattOpenStatus> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattOpenStatus>(_service.OpenAsync((GattSharingMode)3));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattOpenStatus> taskAwaiter2 = default(TaskAwaiter<GattOpenStatus>);
taskAwaiter = taskAwaiter2;
}
GattOpenStatus result = taskAwaiter.GetResult();
return IsOpenSuccess(result);
}
private static bool IsOpenSuccess(GattOpenStatus status)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Invalid comparison between Unknown and I4
if (status - 1 <= 1)
{
return true;
}
return false;
}
private async Task<GattCharacteristic> PlatformGetCharacteristic(BluetoothUuid characteristic)
{
if (!(await OpenAsync()))
{
return null;
}
TaskAwaiter<GattCharacteristicsResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattCharacteristicsResult>(_service.GetCharacteristicsForUuidAsync((Guid)characteristic, (BluetoothCacheMode)0));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattCharacteristicsResult> taskAwaiter2 = default(TaskAwaiter<GattCharacteristicsResult>);
taskAwaiter = taskAwaiter2;
}
GattCharacteristicsResult result = taskAwaiter.GetResult();
GattCharacteristicsResult val = result;
if ((int)val.Status == 0 && val.Characteristics.Count > 0)
{
return new GattCharacteristic(this, val.Characteristics[0]);
}
return null;
}
private async Task<IReadOnlyList<GattCharacteristic>> PlatformGetCharacteristics()
{
if (!(await OpenAsync()))
{
return null;
}
List<GattCharacteristic> characteristics = new List<GattCharacteristic>();
TaskAwaiter<GattCharacteristicsResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattCharacteristicsResult>(_service.GetCharacteristicsAsync((BluetoothCacheMode)0));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattCharacteristicsResult> taskAwaiter2 = default(TaskAwaiter<GattCharacteristicsResult>);
taskAwaiter = taskAwaiter2;
}
GattCharacteristicsResult result = taskAwaiter.GetResult();
GattCharacteristicsResult val = result;
if ((int)val.Status == 0)
{
foreach (GattCharacteristic characteristic in val.Characteristics)
{
characteristics.Add(new GattCharacteristic(this, characteristic));
}
}
return characteristics.AsReadOnly();
}
private async Task<GattService> PlatformGetIncludedServiceAsync(BluetoothUuid service)
{
if (!(await OpenAsync()))
{
return null;
}
TaskAwaiter<GattDeviceServicesResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattDeviceServicesResult>(_service.GetIncludedServicesForUuidAsync((Guid)service, (BluetoothCacheMode)0));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattDeviceServicesResult> taskAwaiter2 = default(TaskAwaiter<GattDeviceServicesResult>);
taskAwaiter = taskAwaiter2;
}
GattDeviceServicesResult result = taskAwaiter.GetResult();
GattDeviceServicesResult val = result;
if ((int)val.Status == 0)
{
return new GattService(Device, val.Services[0], isPrimary: false);
}
return null;
}
private async Task<IReadOnlyList<GattService>> PlatformGetIncludedServicesAsync()
{
if (!(await OpenAsync()))
{
return null;
}
List<GattService> services = new List<GattService>();
TaskAwaiter<GattDeviceServicesResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattDeviceServicesResult>(_service.GetIncludedServicesAsync());
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattDeviceServicesResult> taskAwaiter2 = default(TaskAwaiter<GattDeviceServicesResult>);
taskAwaiter = taskAwaiter2;
}
GattDeviceServicesResult result = taskAwaiter.GetResult();
GattDeviceServicesResult val = result;
if ((int)val.Status == 0)
{
foreach (GattDeviceService service in val.Services)
{
services.Add(new GattService(Device, service, isPrimary: false));
}
return services;
}
return null;
}
private BluetoothUuid GetUuid()
{
return _service.Uuid;
}
private bool GetIsPrimary()
{
return _isPrimary;
}
}
[BluetoothUti("org.bluetooth.service")]
public static class GattServiceUuids
{
internal const string Namespace = "org.bluetooth.service";
[BluetoothUti("generic_access")]
public static readonly BluetoothUuid GenericAccess = (ushort)6144;
[BluetoothUti("alert_notification")]
public static readonly BluetoothUuid AlertNotification = (ushort)6161;
[BluetoothUti("automation_io")]
public static readonly BluetoothUuid AutomationIO = (ushort)6165;
[BluetoothUti("battery_service")]
public static readonly BluetoothUuid Battery = (ushort)6159;
[BluetoothUti("binary_sensor")]
public static readonly BluetoothUuid BinarySensor = (ushort)6203;
[BluetoothUti("blood_pressure")]
public static readonly BluetoothUuid BloodPressure = (ushort)6160;
[BluetoothUti("body_composition")]
public static readonly BluetoothUuid BodyComposition = (ushort)6171;
[BluetoothUti("bond_management")]
public static readonly BluetoothUuid BondManagement = (ushort)6174;
[BluetoothUti("continuous_glucose_monitoring")]
public static readonly BluetoothUuid ContinuousGlucoseMonitoring = (ushort)6175;
[BluetoothUti("current_time")]
public static readonly BluetoothUuid CurrentTime = (ushort)6149;
[BluetoothUti("cycling_power")]
public static readonly BluetoothUuid CyclingPower = (ushort)6168;
[BluetoothUti("cycling_speed_and_cadence")]
public static readonly BluetoothUuid CyclingSpeedAndCadence = (ushort)6166;
[BluetoothUti("device_information")]
public static readonly BluetoothUuid DeviceInformation = (ushort)6154;
[BluetoothUti("environmental_sensing")]
public static readonly BluetoothUuid EnvironmentalSensing = (ushort)6170;
[BluetoothUti("fitness_machine")]
public static readonly BluetoothUuid FitnessMachine = (ushort)6182;
[BluetoothUti("generic_attribute")]
public static readonly BluetoothUuid GenericAttribute = (ushort)6145;
[BluetoothUti("glucose")]
public static readonly BluetoothUuid Glucose = (ushort)6152;
[BluetoothUti("health_thermometer")]
public static readonly BluetoothUuid HealthThermometer = (ushort)6153;
[BluetoothUti("heart_rate")]
public static readonly BluetoothUuid HeartRate = (ushort)6157;
[BluetoothUti("http_proxy")]
public static readonly BluetoothUuid HttpProxy = (ushort)6179;
[BluetoothUti("human_interface_device")]
public static readonly BluetoothUuid HumanInterfaceDevice = (ushort)6162;
[BluetoothUti("immediate_alert")]
public static readonly BluetoothUuid ImmediateAlert = (ushort)6146;
[BluetoothUti("indoor_positioning")]
public static readonly BluetoothUuid IndoorPositioning = (ushort)6177;
[BluetoothUti("insulin_delivery")]
public static readonly BluetoothUuid InsulinDelivery = (ushort)6202;
[BluetoothUti("internet_protocol_support")]
public static readonly BluetoothUuid InternetProtocolSupport = (ushort)6176;
[BluetoothUti("link_loss")]
public static readonly BluetoothUuid LinkLoss = (ushort)6147;
[BluetoothUti("location_and_navigation")]
public static readonly BluetoothUuid LocationAndNavigation = (ushort)6169;
[BluetoothUti("mesh_provisioning")]
public static readonly BluetoothUuid MeshProvisioning = (ushort)6183;
[BluetoothUti("mesh_proxy")]
public static readonly BluetoothUuid MeshProxy = (ushort)6184;
[BluetoothUti("next_dst_change")]
public static readonly BluetoothUuid NextDstChange = (ushort)6151;
[BluetoothUti("object_transfer")]
public static readonly BluetoothUuid ObjectTransfer = (ushort)6181;
[BluetoothUti("phone_alert_status")]
public static readonly BluetoothUuid PhoneAlertStatus = (ushort)6158;
[BluetoothUti("pulse_oximeter")]
public static readonly BluetoothUuid PulseOximeter = (ushort)6178;
[BluetoothUti("reconnection_configuration")]
public static readonly BluetoothUuid ReconnectionConfiguration = (ushort)6185;
[BluetoothUti("reference_time_update")]
public static readonly BluetoothUuid ReferenceTimeUpdate = (ushort)6150;
[BluetoothUti("running_speed_and_cadence")]
public static readonly BluetoothUuid RunningSpeedAndCadence = (ushort)6164;
[BluetoothUti("scan_parameters")]
public static readonly BluetoothUuid ScanParameters = (ushort)6163;
[BluetoothUti("transport_discovery")]
public static readonly BluetoothUuid TransportDiscovery = (ushort)6180;
[BluetoothUti("tx_power")]
public static readonly BluetoothUuid TxPower = (ushort)6148;
[BluetoothUti("user_data")]
public static readonly BluetoothUuid UserData = (ushort)6172;
[BluetoothUti("weight_scale")]
public static readonly BluetoothUuid WeightScale = (ushort)6173;
public static BluetoothUuid FromBluetoothUti(string bluetoothUti)
{
string text = bluetoothUti.ToLower();
if (text.StartsWith("org.bluetooth.service"))
{
text = text.Substring(text.LastIndexOf("."));
}
FieldInfo[] fields = typeof(GattServiceUuids).GetFields(BindingFlags.Static | BindingFlags.Public);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
Attribute customAttribute = fieldInfo.GetCustomAttribute(typeof(BluetoothUtiAttribute));
if (customAttribute != null && ((BluetoothUtiAttribute)customAttribute).Uti == text)
{
return (BluetoothUuid)fieldInfo.GetValue(null);
}
}
return default(BluetoothUuid);
}
public static string GetServiceName(BluetoothUuid uuid, bool includeNamespace = false)
{
ushort? num = BluetoothUuid.TryGetShortId(uuid);
if (num.HasValue && (num.Value & 0xFF00) == 6144)
{
FieldInfo[] fields = typeof(GattServiceUuids).GetFields(BindingFlags.Static | BindingFlags.Public);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
if ((BluetoothUuid)fieldInfo.GetValue(null) == uuid)
{
Attribute customAttribute = fieldInfo.GetCustomAttribute(typeof(BluetoothUtiAttribute));
if (customAttribute != null)
{
return (includeNamespace ? "org.bluetooth.service." : string.Empty) + ((BluetoothUtiAttribute)customAttribute).Uti;
}
return string.Empty;
}
}
}
return string.Empty;
}
}
public sealed class RemoteGattServer
{
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private BluetoothPhy _preferredPhy = BluetoothPhy.Le1m;
public bool AutoConnect { get; set; }
public BluetoothDevice Device { get; private set; }
[Obsolete("Use IsConnected instead", true)]
public bool Connected => IsConnected;
public bool IsConnected => GetConnected();
public int Mtu { get; internal set; }
public BluetoothPhy PreferredPhy
{
get
{
return _preferredPhy;
}
set
{
_preferredPhy = value;
PlatformSetPreferredPhy(value);
}
}
internal RemoteGattServer(BluetoothDevice device)
{
Device = device;
PlatformInit();
}
private void Device_GattServerDisconnected(object sender, EventArgs e)
{
Device.OnGattServerDisconnected();
}
public Task ConnectAsync()
{
return PlatformConnect();
}
public void Disconnect()
{
PlatformDisconnect();
Device.OnGattServerDisconnected();
PlatformCleanup();
}
public Task<GattService> GetPrimaryServiceAsync(BluetoothUuid service)
{
return PlatformGetPrimaryService(service);
}
public Task<List<GattService>> GetPrimaryServicesAsync(BluetoothUuid? service = null)
{
return PlatformGetPrimaryServices(service);
}
public Task<short> ReadRssi()
{
return PlatformReadRssi();
}
private void PlatformInit()
{
Device.NativeDevice.ConnectionStatusChanged += NativeDevice_ConnectionStatusChanged;
}
private void NativeDevice_ConnectionStatusChanged(BluetoothLEDevice sender, object args)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if ((int)sender.ConnectionStatus == 0)
{
Device.OnGattServerDisconnected();
}
}
private bool GetConnected()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Invalid comparison between Unknown and I4
if (Device.IsDisposedItem(Device))
{
return false;
}
return (int)Device.NativeDevice.ConnectionStatus == 1;
}
private async Task PlatformConnect()
{
if (await Device.CreateNativeInstance())
{
PlatformInit();
}
TaskAwaiter<DeviceAccessStatus> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<DeviceAccessStatus>(Device.NativeDevice.RequestAccessAsync());
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<DeviceAccessStatus> taskAwaiter2 = default(TaskAwaiter<DeviceAccessStatus>);
taskAwaiter = taskAwaiter2;
}
DeviceAccessStatus result = taskAwaiter.GetResult();
DeviceAccessStatus val = result;
if ((int)val == 1)
{
Device.LastKnownAddress = Device.NativeDevice.BluetoothAddress;
TaskAwaiter<GattSession> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<GattSession>(GattSession.FromDeviceIdAsync(Device.NativeDevice.BluetoothDeviceId));
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
TaskAwaiter<GattSession> taskAwaiter4 = default(TaskAwaiter<GattSession>);
taskAwaiter3 = taskAwaiter4;
}
GattSession result2 = taskAwaiter3.GetResult();
GattSession val2 = result2;
if (val2 != (GattSession)null)
{
Mtu = val2.MaxPduSize;
val2.MaxPduSizeChanged += Session_MaxPduSizeChanged;
Device.AddDisposableObject(this, (IDisposable)val2);
val2.MaintainConnection = true;
}
TaskAwaiter<GattDeviceServicesResult> taskAwaiter5 = WindowsRuntimeSystemExtensions.GetAwaiter<GattDeviceServicesResult>(Device.NativeDevice.GetGattServicesAsync((BluetoothCacheMode)1));
if (!taskAwaiter5.IsCompleted)
{
await taskAwaiter5;
TaskAwaiter<GattDeviceServicesResult> taskAwaiter6 = default(TaskAwaiter<GattDeviceServicesResult>);
taskAwaiter5 = taskAwaiter6;
}
GattDeviceServicesResult result3 = taskAwaiter5.GetResult();
GattDeviceServicesResult val3 = result3;
{
foreach (GattDeviceService service in val3.Services)
{
service.Dispose();
}
return;
}
}
throw new SecurityException();
}
private void Session_MaxPduSizeChanged(GattSession sender, object args)
{
Mtu = sender.MaxPduSize;
}
private void PlatformDisconnect()
{
}
private void PlatformCleanup()
{
if (Device.NativeDisposeList.TryGetValue(Device.GetHashCode(), out var value) && value != null)
{
Device.NativeDevice.ConnectionStatusChanged -= NativeDevice_ConnectionStatusChanged;
Device.DisposeAllNativeObjects();
}
}
private async Task<GattService> PlatformGetPrimaryService(BluetoothUuid service)
{
if (await Device.CreateNativeInstance())
{
PlatformInit();
}
TaskAwaiter<GattDeviceServicesResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattDeviceServicesResult>(Device.NativeDevice.GetGattServicesForUuidAsync((Guid)service, (BluetoothCacheMode)1));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
TaskAwaiter<GattDeviceServicesResult> taskAwaiter2 = default(TaskAwaiter<GattDeviceServicesResult>);
taskAwaiter = taskAwaiter2;
}
GattDeviceServicesResult result = taskAwaiter.GetResult();
GattDeviceServicesResult val = result;
if (val == (GattDeviceServicesResult)null || val.Services.Count == 0)
{
return null;
}
return new GattService(Device, val.Services[0], isPrimary: true);
}
private async Task<List<GattService>> PlatformGetPrimaryServices(BluetoothUuid? service)
{
if (await Device.CreateNativeInstance())
{
PlatformInit();
}
List<GattService> services = new List<GattService>();
BluetoothLEDevice nativeDevice = Device.NativeDevice;
BluetoothCacheMode val = (BluetoothCacheMode)((!nativeDevice.DeviceInformation.Pairing.IsPaired) ? 1 : 0);
TaskAwaiter<GattDeviceServicesResult> taskAwaiter2 = default(TaskAwaiter<GattDeviceServicesResult>);
GattDeviceServicesResult val2;
if (!service.HasValue)
{
TaskAwaiter<GattDeviceServicesResult> taskAwaiter = WindowsRuntimeSystemExtensions.GetAwaiter<GattDeviceServicesResult>(nativeDevice.GetGattServicesAsync(val));
if (!taskAwaiter.IsCompleted)
{
await taskAwaiter;
taskAwaiter = taskAwaiter2;
}
GattDeviceServicesResult result = taskAwaiter.GetResult();
val2 = result;
}
else
{
TaskAwaiter<GattDeviceServicesResult> taskAwaiter3 = WindowsRuntimeSystemExtensions.GetAwaiter<GattDeviceServicesResult>(nativeDevice.GetGattServicesForUuidAsync((Guid)service.Value, val));
if (!taskAwaiter3.IsCompleted)
{
await taskAwaiter3;
taskAwaiter3 = taskAwaiter2;
}
GattDeviceServicesResult result2 = taskAwaiter3.GetResult();
val2 = result2;
}
if (val2 != (GattDeviceServicesResult)null && val2.Services.Count > 0)
{
foreach (GattDeviceService service2 in val2.Services)
{
services.Add(new GattService(Device, service2, isPrimary: true));
}
}
return services;
}
private Task<short> PlatformReadRssi()
{
return Task.FromResult((short)0);
}
private void PlatformSetPreferredPhy(BluetoothPhy phy)
{
}
}
public sealed class RequestDeviceOptions
{
public IList<BluetoothLEScanFilter> Filters { get; } = new List<BluetoothLEScanFilter>();
public IList<Guid> OptionalServices { get; } = new List<Guid>();
public bool AcceptAllDevices { get; set; }
}
