protected override async Task <bool> StartScanningForDevicesNativeAsync(Guid[] serviceUuids,
Boolean allowDuplicatesKey, CancellationToken scanCancellationToken)
{
// Wait for the PoweredOn state
await this.WaitForState(CBCentralManagerState.PoweredOn, scanCancellationToken).ConfigureAwait(false);
if (scanCancellationToken.IsCancellationRequested)
{
throw new TaskCanceledException("StartScanningForDevicesNativeAsync cancelled");
}
Trace.Message("Adapter: Starting a scan for devices.");
CBUUID[] serviceCbuuids = null;
if (serviceUuids != null && serviceUuids.Any())
{
serviceCbuuids = serviceUuids.Select(u => CBUUID.FromString(u.ToString())).ToArray();
Trace.Message("Adapter: Scanning for " + serviceCbuuids.First());
}
this.DiscoveredDevices.Clear();
this._centralManager.ScanForPeripherals(serviceCbuuids,
new PeripheralScanningOptions {
AllowDuplicatesKey = allowDuplicatesKey
});
return(true);
}
public static BeaconInfo BeaconInfoForUIDFrameData(NSDictionary advertisementFrameList, NSData telemetry, int rssi)
{
var frameData = advertisementFrameList.ObjectForKey(CBUUID.FromString("FEAA")) as NSData;
if (frameData.Length > 1)
{
var frameBytes = frameData.ToArray();
if (frameBytes[0] != EddystoneUIDFrameTypeID)
{
System.Diagnostics.Debug.WriteLine("Unexpected non UID Frame passed to BeaconInfoForUIDFrameData.");
return(null);
}
else if (frameBytes.Length < 18)
{
System.Diagnostics.Debug.WriteLine("Frame Data for UID Frame unexpectedly truncated in BeaconInfoForUIDFrameData.");
}
var txPower = Convert.ToInt32(frameBytes[1]);
var beaconID = new byte [frameBytes.Length - 2];
Array.Copy(frameBytes, 2, beaconID, 0, beaconID.Length);
var bid = new BeaconID(BeaconType.Eddystone, beaconID);
return(new BeaconInfo(bid, txPower, rssi, telemetry));
}
return(null);
}
public void FullRandomEquals()
{
var guid = Guid.NewGuid();
Assert.That(CBUUID.FromBytes(guid.ToByteArray()),
Is.EqualTo(CBUUID.FromBytes(guid.ToByteArray())));
}
public override void DiscoveredService(CBPeripheral peripheral, NSError error)
{
var descriptor = peripheral.ToDeviceDescriptor();
if (error != null)
{
_deviceManager.HandleDeviceCommunicationDiscoveryServiceError(descriptor, error.LocalizedFailureReason, (d) =>
{
_centralManager.CancelPeripheralConnection(peripheral);
});
return;
}
CBUUID uuidCharacteristic = CBUUID.FromString(_tracingInformation.CharacteristicId);
CBUUID uuidService = CBUUID.FromString(_tracingInformation.ServiceId);
var service = peripheral.Services.FirstOrDefault(x => x.UUID == uuidService);
if (service != null)
{
_deviceManager.HandleDeviceCommunicationDiscoveredService(descriptor, (d) =>
{
peripheral.DiscoverCharacteristics(new[] { uuidCharacteristic }, service);
});
}
else
{
_deviceManager.HandleIncorrectDevice(descriptor);
_centralManager.CancelPeripheralConnection(peripheral);
}
}
public void Equality_PartialEqualsFull()
{
using (var u1 = CBUUID.FromPartial(0x0127))
using (var u2 = MakeFull(0x01, 0x27)) {
Assert.True(u1.Equals((object)u2), "Equals-1a");
Assert.True(u1.Equals((NSObject)u2), "Equals-1b");
Assert.True(u1.Equals((CBUUID)u2), "Equals-1b");
Assert.That(u1.GetHashCode(), Is.EqualTo(u2.GetHashCode()), "GetHashCode-1");
}
using (var u1 = CBUUID.FromBytes(new byte [] { 0xab, 0xcd }))
using (var u2 = MakeFull(0xab, 0xcd)) {
Assert.True(u1.Equals((object)u2), "Equals-2a");
Assert.True(u1.Equals((NSObject)u2), "Equals-2b");
Assert.True(u1.Equals((CBUUID)u2), "Equals-2b");
Assert.That(u1.GetHashCode(), Is.EqualTo(u2.GetHashCode()), "GetHashCode-2");
}
using (var u1 = CBUUID.FromString("1234"))
using (var u2 = CBUUID.FromString("00001234-0000-1000-8000-00805f9b34fb")) {
Assert.True(u1.Equals((object)u2), "Equals-3a");
Assert.True(u1.Equals((NSObject)u2), "Equals-3b");
Assert.True(u1.Equals((CBUUID)u2), "Equals-3b");
Assert.That(u1.GetHashCode(), Is.EqualTo(u2.GetHashCode()), "GetHashCode-3");
}
#if MONOMAC
Assert.That(CBUUID.FromBytes(new byte [] { 0xab, 0xcd, 0xef, 0x12 }),
Is.EqualTo(MakeFull(0xab, 0xcd, 0xef, 0x12)));
Assert.That(CBUUID.FromString("12345678"),
Is.EqualTo(CBUUID.FromString("12345678-0000-1000-8000-00805f9b34fb")));
#endif
}
public async Task StartAdvertising(string localName, List <IService> services)
{
if (_peripheralManager.State != CBPeripheralManagerState.PoweredOn)
{
throw new InvalidStateException((ManagerState)_peripheralManager.State);
}
var cbuuIdArray = new NSMutableArray();
var optionsDict = new NSMutableDictionary();
if (services != null)
{
foreach (Service service in services)
{
cbuuIdArray.Add(CBUUID.FromString(service.Uuid));
//_peripheralManager.AddService((CBMutableService) service.NativeService);
}
optionsDict[CBAdvertisement.DataServiceUUIDsKey] = cbuuIdArray;
}
if (localName != null)
{
optionsDict[CBAdvertisement.DataLocalNameKey] = new NSString(localName);
}
_peripheralManager.StartAdvertising(optionsDict);
}
protected void Initialize()
{
this._tableSource = new CharacteristicTableSource();
// // when the characteristic is selected in the table, make a request to disover the descriptors for it.
this._tableSource.CharacteristicSelected += (object sender, CharacteristicTableSource.CharacteristicSelectedEventArgs e) => {
Console.WriteLine("Characteristic: " + e.Characteristic.Name);
UIViewController _characteristicDetailScreen = null;
if (e.Characteristic.Uuid == CBUUID.FromPartial(0x2A37).ToString()) // heart rate characteristic
{
_characteristicDetailScreen = new CharacteristicDetailScreen_Hrm();
((CharacteristicDetailScreen_Hrm)_characteristicDetailScreen).SetDeviceServiceAndCharacteristic(this._connectedDevice, this._currentService, e.Characteristic);
}
if (_connectedDevice.Name == "TI BLE Sensor Tag") // TI SensorTag device
{
_characteristicDetailScreen = new CharacteristicDetailScreen_TISensorTag();
((CharacteristicDetailScreen_TISensorTag)_characteristicDetailScreen).SetDeviceServiceAndCharacteristic(this._connectedDevice, this._currentService, e.Characteristic);
}
else
{
_characteristicDetailScreen = new CharacteristicDetailScreen();
((CharacteristicDetailScreen)_characteristicDetailScreen).SetDeviceServiceAndCharacteristic(this._connectedDevice, this._currentService, e.Characteristic);
}
this.NavigationController.PushViewController(_characteristicDetailScreen, true);
};
}
public async void StartScanningForDevices(Guid serviceUuid, int timeOutSeconds = 10)
{
//
// Wait for the PoweredOn state
//
await WaitForState(CBCentralManagerState.PoweredOn);
Debug.WriteLine("Adapter: Starting a scan for devices.");
CBUUID[] serviceUuids = null; // TODO: convert to list so multiple Uuids can be detected
if (serviceUuid != Guid.Empty)
{
var suuid = CBUUID.FromString(serviceUuid.ToString());
serviceUuids = new CBUUID[] { suuid };
Debug.WriteLine("Adapter: Scanning for " + suuid);
}
// clear out the list
this._discoveredDevices = new List <IDevice> ();
// start scanning
this._isScanning = true;
this._central.ScanForPeripherals(serviceUuids);
// in 10 seconds, stop the scan
await Task.Delay(TimeSpan.FromSeconds(timeOutSeconds));
// if we're still scanning
if (this._isScanning)
{
Console.WriteLine("BluetoothLEManager: Scan timeout has elapsed.");
StopScanningForDevices();
this.ScanTimeoutElapsed(this, new EventArgs());
}
}
public void Build(CBMutableService service)
{
this.native = new CBMutableCharacteristic(
CBUUID.FromString(this.Uuid),
this.properties,
null,
this.permissions
);
service.Characteristics = service.Characteristics.Expand(this.native);
if (this.onWrite != null)
{
this.manager.WriteRequestsReceived += this.OnWrite;
}
if (this.onRead != null)
{
this.manager.ReadRequestReceived += this.OnRead;
}
if (this.onSubscribe != null)
{
this.manager.CharacteristicSubscribed += this.OnSubscribed;
this.manager.CharacteristicUnsubscribed += this.OnUnSubscribed;
}
}
public static CBUUID ToCBUUID(this Guid guid)
{
var bytes = guid.ToByteArray();
return(CBUUID.FromString(guid.ToString()));
//return CBUUID.FromBytes(guid.ToByteArray());
}
public void Start(TracingInformation tracingInformation)
{
if (tracingInformation == null || _enabled)
{
return;
}
_tracingInformation = tracingInformation;
_peripheralManager.RemoveAllServices();
CBUUID uuidService = CBUUID.FromString(tracingInformation.ServiceId);
CBUUID uuidCharacteristic = CBUUID.FromString(tracingInformation.CharacteristicId);
var data = NSData.FromArray(PayloadFormatter.GetBytesToSend(new PackageData(tracingInformation.DeviceId)));
var characteristic = new CBMutableCharacteristic(uuidCharacteristic, CBCharacteristicProperties.Read, data, CBAttributePermissions.Readable);
var service = new CBMutableService(uuidService, true);
service.Characteristics = new CBCharacteristic[] { characteristic };
_peripheralManager.AddService(service);
StartAdvertisingOptions advData = new StartAdvertisingOptions {
ServicesUUID = new CBUUID[] { uuidService }
};
_peripheralManager.StartAdvertising(advData);
TracingState.Instance.SetAdvertisingState(true);
_enabled = true;
_logger.LogDebug("Advertising starting. DeviceId: " + _tracingInformation.DeviceId);
}
public async void StartScanningForDevices(Guid serviceUuid)
{
await WaitForState(CBCentralManagerState.PoweredOn);
Debug.WriteLine("Adapter: Starting a scan for devices.");
CBUUID[] serviceUuids = null; // TODO: convert to list so multiple Uuids can be detected
if (serviceUuid != Guid.Empty)
{
var suuid = CBUUID.FromString(serviceUuid.ToString());
serviceUuids = new CBUUID[] { suuid };
Debug.WriteLine("Adapter: Scanning for " + suuid);
}
this._discoveredDevices = new List <IDevice>();
this._isScanning = true;
this._central.ScanForPeripherals(serviceUuids);
await Task.Delay(10000);
if (this._isScanning)
{
Console.WriteLine("BluetoothLEManager: Scan timeout has elapsed.");
this._isScanning = false;
this._central.StopScan();
this.ScanTimeoutElapsed(this, new EventArgs());
}
}
public async void StartScanningForDevices(Guid serviceUuid)
{
await WaitForState(CBCentralManagerState.PoweredOn);
Debug.WriteLine("Adapter: Starting a scan for devices.");
CBUUID[] serviceUuids = null; // TODO: convert to list so multiple Uuids can be detected
if (serviceUuid != Guid.Empty)
{
var suuid = CBUUID.FromString(serviceUuid.ToString());
serviceUuids = new CBUUID[] { suuid };
Debug.WriteLine("Adapter: Scanning for " + suuid);
}
// clear out the list
DiscoveredDevices = new List <IDevice>();
// start scanning
IsScanning = true;
CentralManager.ScanForPeripherals(serviceUuids);
// in 10 seconds, stop the scan
await Task.Delay(10000);
// if we're still scanning
if (IsScanning)
{
Console.WriteLine("Adapter: Scan timeout has elapsed.");
IsScanning = false;
CentralManager.StopScan();
ScanTimeoutElapsed(this, new EventArgs());
}
}
public static EddystoneFrameType FrameTypeForFrame(NSDictionary advertisementFrameList)
{
var uuid = CBUUID.FromString("FEAA");
var frameData = advertisementFrameList[uuid] as NSData;
if (frameData != null)
{
var count = frameData.Length;
if (count > 1)
{
var frameBytes = Enumerable.Repeat((byte)0, (int)count).ToArray();
Marshal.Copy(frameData.Bytes, frameBytes, 0, (int)count);
if (frameBytes[0] == BeaconInfo.EddystoneUIDFrameTypeID)
{
return(BeaconInfo.EddystoneFrameType.UIDFrameType);
}
else if (frameBytes[0] == BeaconInfo.EddystoneTLMFrameTypeID)
{
return(BeaconInfo.EddystoneFrameType.TelemetryFrameType);
}
else if (frameBytes[0] == BeaconInfo.EddystoneEIDFrameTypeID)
{
return(BeaconInfo.EddystoneFrameType.EIDFrameType);
}
else if (frameBytes[0] == BeaconInfo.EddystoneURLFrameTypeID)
{
return(BeaconInfo.EddystoneFrameType.URLFrameType);
}
}
}
return(EddystoneFrameType.UnknownFrameType);
}
public void StartScan(BleDevice device)
{
_CentralManager = new CBCentralManager(this, null);
if (device == null)
{
throw new Exception("Could not start client without a service type to scan for.");
}
_CentralManager.DiscoveredPeripheral += (o, e) =>
{
DeviceFound?.Invoke(this, new DeviceEventArgs {
Device = new BleDevice {
Guid = e.Peripheral.UUID.Uuid
}
});
};
_CentralManager.ConnectedPeripheral += (o, e) =>
{
DeviceConnected?.Invoke(this, new DeviceEventArgs {
Device = new BleDevice {
Guid = e.Peripheral.UUID.Uuid
}
});
};
//_CentralManager.ScanForPeripherals(CBUUID.FromPartial(device.GuidValue));
_CentralManager.ScanForPeripherals(CBUUID.FromString(device.Guid));
}
public BtError enumerateDevices()
{
if (!isScanning)
{
devices.Clear();
deviceAddresses.Clear();
serviceObjects.Clear();
characteristicObjects.Clear();
descriptorObjects.Clear();
var error = checkBtSupport();
if (error != BtError.None)
{
return(error);
}
var uuids = new List <CBUUID>();
foreach (var s in scanServices)
{
uuids.Add(CBUUID.FromString(s));
}
var options = new PeripheralScanningOptions();
options.AllowDuplicatesKey = true;
centralManager.ScanForPeripherals(uuids.ToArray(), options);
isScanning = true;
return(BtError.None);
}
else
{
return(BtError.AlreadyRunning);
}
}
public static EddystoneFrameType FrameTypeForFrame(NSDictionary advertisementFrameList)
{
var frameData = advertisementFrameList.ObjectForKey(CBUUID.FromString("FEAA")) as NSData;
if (frameData != null && frameData.Length >= 1)
{
var frameBytes = frameData.ToArray();
if (frameBytes[0] == EddystoneUIDFrameTypeID)
{
return(EddystoneFrameType.UIDFrameType);
}
else if (frameBytes[0] == EddystoneTLMFrameTypeID)
{
return(EddystoneFrameType.TelemetryFrameType);
}
else if (frameBytes[0] == EddystoneEIDFrameTypeID)
{
return(EddystoneFrameType.EIDFrameType);
}
else if (frameBytes[0] == EddystoneURLFrameTypeID)
{
return(EddystoneFrameType.URLFrameType);
}
else
{
return(EddystoneFrameType.UnknownFrameType);
}
}
return(EddystoneFrameType.UnknownFrameType);
}
void UpdateScan()
{
if (_scanners.Count == 0)
{
_central.StopScan();
}
else
{
HashSet <ServiceUuid> services = null;
if (!_scanners.Any(scn => scn.Services == null))
{
// all scanners want only specific services, create a union over all
services = new HashSet <ServiceUuid>();
foreach (var scn in _scanners)
{
services.UnionWith(scn.Services);
}
}
_central.ScanForPeripherals(services?.Select(uuid => CBUUID.FromBytes(uuid.Uuid.ToByteArrayBE())).ToArray(), new PeripheralScanningOptions
{
AllowDuplicatesKey = true,
});
}
}
/// <summary>
/// Gets the paired devices.
/// </summary>
/// <returns>Task<IReadOnlyList<IBluetoothDevice>>.</returns>
public async Task <IReadOnlyList <IBluetoothDevice> > GetPairedDevices()
{
return(await Task.Factory.StartNew(() =>
{
var devices = new List <IBluetoothDevice>();
var action = new EventHandler <CBPeripheralsEventArgs>((s, e) =>
devices.AddRange(e.Peripherals.Select(a => new BluetoothDevice(a))));
this.manager.RetrievedPeripherals += action;
this.manager.RetrievedConnectedPeripherals += ManagerOnRetrievedConnectedPeripherals;
this.manager.DiscoveredPeripheral += manager_DiscoveredPeripheral;
//CBUUID id = null;
// Bug in Xamarin? https://bugzilla.xamarin.com/show_bug.cgi?id=5808
//this.manager.ScanForPeripherals(id, null);
this.manager.ScanForPeripherals(CBUUID.FromString(TransferServiceUuid));
this.manager.RetrievePeripherals(CBUUID.FromString(TransferServiceUuid));
//this.manager.RetrieveConnectedPeripherals(new[] { CBUUID.FromString(TransferServiceUuid) });
this.manager.RetrievedPeripherals -= action;
this.manager.RetrievedConnectedPeripherals -= ManagerOnRetrievedConnectedPeripherals;
this.manager.DiscoveredPeripheral -= manager_DiscoveredPeripheral;
return devices;
}));
}
static CBUUID MakeFull(byte a, byte b, byte c, byte d)
{
return(CBUUID.FromBytes(new byte [] {
a, b, c, d, 0x00, 0x00, 0x10, 0x00,
0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb
}));
}
public async Task <CBService> GetService(CBPeripheral peripheral, string serviceUuid)
{
var service = this.GetServiceIfDiscovered(peripheral, serviceUuid);
if (service != null)
{
return(service);
}
var taskCompletion = new TaskCompletionSource <bool>();
var task = taskCompletion.Task;
EventHandler <NSErrorEventArgs> handler = (s, e) =>
{
if (this.GetServiceIfDiscovered(peripheral, serviceUuid) != null)
{
taskCompletion.SetResult(true);
}
};
try
{
peripheral.DiscoveredService += handler;
peripheral.DiscoverServices(new[] { CBUUID.FromString(serviceUuid) });
await this.WaitForTaskWithTimeout(task, ConnectionTimeout);
return(this.GetServiceIfDiscovered(peripheral, serviceUuid));
}
finally
{
peripheral.DiscoveredService -= handler;
}
}
public Characteristic(Guid uuid, CharacterisiticPermissionType permissions, CharacteristicPropertyType properties)
{
CBAttributePermissions nativePermissions = 0;
nativePermissions = GetNativePermissions(permissions);
_nativeCharacteristic = new CBMutableCharacteristic(CBUUID.FromString(uuid.ToString()), (CBCharacteristicProperties)properties, null, nativePermissions);
}
public Task <byte[]> ReadValue(string characteristicGuid, bool important = false)
{
var cbuuid = CBUUID.FromString(characteristicGuid);
// TODO: Check for connected devices?
if (_characteristics.ContainsKey(cbuuid) == false)
{
// TODO Error?
return(null);
}
// Already awaiting it.
if (_readQueue.ContainsKey(cbuuid))
{
return(_readQueue[cbuuid].Task);
}
var taskCompletionSource = new TaskCompletionSource <byte[]>();
if (important)
{
// TODO: Put this at the start of the queue.
_readQueue.Add(cbuuid, taskCompletionSource);
}
else
{
_readQueue.Add(cbuuid, taskCompletionSource);
}
_peripheral.ReadValue(_characteristics[cbuuid]);
return(taskCompletionSource.Task);
}
public static Guid ToGuid(this CBUUID guid)
{
return(Guid.Parse(guid.ToString()));
//var bytes = guid.ToByteArray();
//return CBUUID.FromString(guid.ToString());
//return CBUUID.FromBytes(guid.ToByteArray());
}
public void Equality_PartialsOfDifferentSizeNotEqual()
{
#if MONOMAC
Assert.That(CBUUID.FromPartial(0x1234), Is.Not.EqualTo(
CBUUID.FromBytes(new byte [] { 0x12, 0x34, 0x56, 0x78 })));
#endif
}
public void WakeUp(CBPeripheral peripheral)
{
// Method that sends commands to sphero in specific order to wake it up
// Create required data
NSData antiDOS = NSData.FromString("011i3");
var txdata = new byte[1];
txdata[0] = 0x07;
NSData TXdata = NSData.FromArray(txdata);
var wakeupdata = new byte[1];
wakeupdata[0] = 0x01;
NSData WakeupData = NSData.FromArray(wakeupdata);
// Notes
// peripheral.Services[0].Characteristics is Control/Response Characteristics
// Control first, then Response
// peripheral.Services[1].Characteristics is Radio Service Characteristics
// peripheral.Services[2].Characteristics is Device Info Characteristics
// peripheral.Services[3].Characteristics is Device Information
// Sending the wake up commands to the sphero
// Can be simplified (either if discovery of services and characteristics are static, or by sorting the arrays
// that information is contained in. For now this is just a working version.
foreach (var characteristic in peripheral.Services[1].Characteristics)
{
if (characteristic.UUID == CBUUID.FromString("22bb746f-2bbd-7554-2D6F-726568705327"))
{
Console.WriteLine("Writing to Anti DOS");
peripheral.WriteValue(antiDOS, characteristic, CBCharacteristicWriteType.WithResponse);
}
}
foreach (var characteristic in peripheral.Services[1].Characteristics)
{
if (characteristic.UUID == CBUUID.FromString("22bb746f-2bb2-7554-2D6F-726568705327"))
{
Console.WriteLine("Writing to TX Power");
peripheral.WriteValue(TXdata, characteristic, CBCharacteristicWriteType.WithResponse);
}
}
foreach (var characteristic in peripheral.Services[1].Characteristics)
{
if (characteristic.UUID == CBUUID.FromString("22bb746f-2bbf-7554-2D6F-726568705327"))
{
Console.WriteLine("Writing to Wakeup");
peripheral.WriteValue(WakeupData, characteristic, CBCharacteristicWriteType.WithResponse);
}
}
/*
* peripheral.WriteValue(antiDOS, peripheral.Services[1].Characteristics[3], CBCharacteristicWriteType.WithResponse);
* peripheral.WriteValue(TXdata, peripheral.Services[1].Characteristics[0], CBCharacteristicWriteType.WithResponse);
* peripheral.WriteValue(WakeupData, peripheral.Services[1].Characteristics[5], CBCharacteristicWriteType.WithResponse);
*/
}
public GattService(CBPeripheralManager manager, string uuid, bool primary)
{
this.manager = manager;
this.Native = new CBMutableService(CBUUID.FromString(uuid), primary);
this.characteristics = new List <GattCharacteristic>();
this.Uuid = uuid;
this.Primary = primary;
}
public void Equality_PartialsOfDifferentSizeNotEqual()
{
TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 10, throwIfOtherPlatform: false);
#if MONOMAC
Assert.That(CBUUID.FromPartial(0x1234), Is.Not.EqualTo(
CBUUID.FromBytes(new byte [] { 0x12, 0x34, 0x56, 0x78 })));
#endif
}
public void ClearUnusedConnections()
{
connectionLookup.Clear();
foreach (var device in ion.deviceManager.knownDevices)
{
connectionLookup[CBUUID.FromString(device.connection.address)] = device.connection;
}
}
public void subscribeToUartChars()
{
var tx = getCharacteristic(CBUUID.FromString(BTValues.txCharacteristic));
if (tx != null && connectedPeripheral != null)
{
connectedPeripheral.SetNotifyValue(true, tx);
}
}
public static Guid ServiceUuidToGuid ( CBUUID uuid)
{
//this sometimes returns only the significant bits, e.g.
//180d or whatever. so we need to add the full string
string id = uuid.ToString ();
if (id.Length == 4) {
id = "0000" + id + "-0000-1000-8000-00805f9b34fb";
}
return Guid.ParseExact (id, "d");
}
private NSDictionary CreateAdvertisementData(string name, CBUUID serviceUuid)
{
return NSDictionary.FromObjectsAndKeys(
new NSObject[]
{
NSArray.FromNSObjects(serviceUuid), new NSString(name)
},
new NSObject[]
{
CBAdvertisement.DataServiceUUIDsKey, CBAdvertisement.DataLocalNameKey
});
}
public static bool IsUuidEqual(this CBCharacteristic characteristic, CBUUID uuid)
{
var result = characteristic.UUID == uuid;
return result;
}
public async void StartScanningForDevices (Guid serviceUuid)
{
//
// Wait for the PoweredOn state
//
await WaitForState (CBCentralManagerState.PoweredOn);
Debug.WriteLine ("Adapter: Starting a scan for devices.");
CBUUID[] serviceUuids = null; // TODO: convert to list so multiple Uuids can be detected
if (serviceUuid != Guid.Empty) {
var suuid = CBUUID.FromString (serviceUuid.ToString ());
serviceUuids = new CBUUID[] { suuid };
Debug.WriteLine ("Adapter: Scanning for " + suuid);
}
// clear out the list
this._discoveredDevices = new List<IDevice> ();
// start scanning
this._isScanning = true;
this._central.ScanForPeripherals ( serviceUuids );
// in 10 seconds, stop the scan
await Task.Delay (10000);
// if we're still scanning
if (this._isScanning) {
Console.WriteLine ("BluetoothLEManager: Scan timeout has elapsed.");
this._isScanning = false;
this._central.StopScan ();
this.ScanTimeoutElapsed (this, new EventArgs ());
}
}
