public void disconnect()
{
if (_isConnected)
{
centralManager.CancelPeripheralConnection(connectedPeripheral);
serviceObjects.Clear();
characteristicObjects.Clear();
descriptorObjects.Clear();
connectedPeripheral = null;
_isConnected = false;
}
}
public Task ConnectToDeviceAsync(IBTDevice device, CancellationToken cancellationToken = default)
{
if (device != null)
{
centralManager.ConnectPeripheral(device.NativeDevice as CBPeripheral, new PeripheralConnectionOptions());
cancellationToken.Register(() =>
{
Console.WriteLine("Canceling the connect attempt");
centralManager.CancelPeripheralConnection(device.NativeDevice as CBPeripheral);
});
}
return(Task.FromResult(true));
}
public Task Disconnect()
{
Debug.WriteLine("Disconnect");
_requestingDisconnect = true;
_disconnectionCompletionSource = new TaskCompletionSource <bool>();
_centralManager.CancelPeripheralConnection(_peripheral);
return(_disconnectionCompletionSource.Task);
}
/// <summary>
/// Discconnect from a device.
/// </summary>
/// <param name="device">The device.</param>
public void DisconnectDevice(IDevice device)
{
var peripheral = device.NativeDevice as CBPeripheral;
if (peripheral != null && peripheral.State != CBPeripheralState.Disconnected)
{
_centralManager.CancelPeripheralConnection(peripheral);
}
}
/// <summary>
/// Connect to a device.
/// </summary>
/// <param name="device">The device.</param>
public async void ConnectToDevice(IDevice device)
{
var peripheral = device.NativeDevice as CBPeripheral;
_central.ConnectPeripheral(peripheral);
await Task.Delay(ConnectionTimeout);
if (ConnectedDevices.All(x => x.Id != device.Id))
{
_central.CancelPeripheralConnection(peripheral);
var args = new DeviceConnectionEventArgs(device)
{
ErrorMessage = "The device connection timed out."
};
DeviceFailedToConnect(this, args);
}
}
private void DisconnectPeripheral(CBCentralManager central, CBPeripheral peripheral)
{
try
{
central.CancelPeripheralConnection(peripheral);
}
catch (Exception ex)
{
SensusServiceHelper.Get().Logger.Log("Exception while disconnecting peripheral: " + ex, LoggingLevel.Normal, GetType());
}
}
public void DisconnectDevice(IDevice device)
{
if (device.State == DeviceState.Connected)
{
_central.CancelPeripheralConnection(device.NativeDevice as CBPeripheral);
}
else
{
Debug.WriteLine("Not connected.. Still trying to disconnect..");
}
}
public void Disconnect()
{
lock (_lock)
{
_onDeviceDisconnected = null;
_onCharacteristicChanged = null;
_centralManager.CancelPeripheralConnection(_peripheral);
State = BluetoothLEDeviceState.Disconnected;
}
}
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 async partial ValueTask DisposeAsync()
{
if (peripheral.State == CBPeripheralState.Disconnected)
{
return;
}
var errorAwaiter = centralDelegate.DisconnectedPeripheralObservable
.FirstAsync(x => x.peripheral.Identifier == peripheral.Identifier)
.GetAwaiter();
central.CancelPeripheralConnection(peripheral);
var(_, error) = await errorAwaiter;
}
//TODO: rename to DisconnectDevice
public void DisconnectPeripheral(CBPeripheral peripheral)
{
_central.CancelPeripheralConnection(peripheral);
}
public void DisconnectDevice(IDevice device)
{
// update registry
DeviceOperationRegistry[device.ID.ToString()] = device;
_central.CancelPeripheralConnection(device.NativeDevice as CBPeripheral);
}
public void DisconnectPeripheral(CBPeripheral peripheral)
{
mCentralManager.CancelPeripheralConnection(peripheral);
}
public void Disconnect()
{
central.DisconnectedPeripheral += DisconnectedPeripheral;
central.CancelPeripheralConnection(connectedCbPeripheral);
}
public void Disconnect(CBPeripheral peripheral)
{
_manager.CancelPeripheralConnection(peripheral);
Debug.WriteLine($"Device {peripheral.Name} disconnected");
}
public void DisconnectFromPeripheral(IBLEPeripheral peripheral)
{
nativeManager.CancelPeripheralConnection(((peripheral as BLEPeripheral).NativePeripheral as CBPeripheral));
}
protected override void DisconnectDeviceNative(IDevice device)
{
_deviceOperationRegistry[device.Id.ToString()] = device;
_centralManager.CancelPeripheralConnection(device.NativeDevice as CBPeripheral);
}
public void Disconnect()
{
_centralManager.CancelPeripheralConnection(_device);
}
private void Disconnect()
{
_manager.CancelPeripheralConnection(_peripheral);
}
private void DisconnectInternal()
{
_centralManager.CancelPeripheralConnection(_peripheral);
State = BluetoothLEDeviceState.Disconnected;
}
public Bluetooth()
{
Devices = new ObservableCollection <BluetoothDevice> ();
ConnectedDevices = new ObservableCollection <BluetoothDevice> ();
_peripherialMap = new Dictionary <BluetoothDevice, CBPeripheral> ();
_deviceMap = new Dictionary <CBPeripheral, BluetoothDevice> ();
_manager = new CBCentralManager(CoreFoundation.DispatchQueue.CurrentQueue);
_manager.DiscoveredPeripheral += (object sender, CBDiscoveredPeripheralEventArgs e) => {
try {
var name = e.Peripheral.Name;
var uuid = e.AdvertisementData.ContainsKey(UUIDField) ? (e.AdvertisementData[UUIDField] as NSArray).GetItem <NSObject>(0).Description : null;
if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(uuid))
{
name = name.Trim(new char[] { '\r', '\n' });
var device = _peripherialMap.Any(i => i.Key.Name == name && i.Key.UUID == uuid) ? _peripherialMap.FirstOrDefault(i => i.Key.Name == name && i.Key.UUID == uuid).Key : new BluetoothDevice(name, uuid);
_peripherialMap[device] = e.Peripheral;
if (!Devices.Contains(device))
{
Devices.Add(device);
}
}
} catch (Exception) {
}
};
_manager.DisconnectedPeripheral += (object sender, CBPeripheralErrorEventArgs e) => {
try {
if (_peripherialMap.ContainsValue(e.Peripheral))
{
var device = _peripherialMap.First(i => i.Value == e.Peripheral).Key;
_peripherialMap.Remove(device);
if (_deviceMap.ContainsKey(e.Peripheral))
{
_deviceMap.Remove(e.Peripheral);
}
if (Devices.Contains(device))
{
Devices.Remove(device);
}
if (ConnectedDevices.Contains(device))
{
ConnectedDevices.Remove(device);
}
}
} catch (Exception) {
}
};
_manager.UpdatedState += (object sender, EventArgs e) => {
if (_startScann && _manager.State == CBCentralManagerState.PoweredOn)
{
StartScan();
}
};
_manager.ConnectedPeripheral += (object sender, CBPeripheralEventArgs e) => {
if (_peripherialMap.ContainsValue(e.Peripheral))
{
_deviceMap[e.Peripheral] = _peripherialMap.FirstOrDefault(i => i.Value == e.Peripheral).Key;
var device = _deviceMap[e.Peripheral];
if (!ConnectedDevices.Contains(device))
{
ConnectedDevices.Add(device);
}
e.Peripheral.DiscoveredService += (object sender2, NSErrorEventArgs e2) => {
//System.Console.WriteLine ("Discovered a service");
foreach (var service in e.Peripheral.Services)
{
Console.WriteLine(service.ToString());
e.Peripheral.DiscoverCharacteristics(service);
}
};
e.Peripheral.DiscoveredCharacteristic += (object sender2, CBServiceEventArgs e2) => {
//System.Console.WriteLine ("Discovered characteristics of " + e.Peripheral);
foreach (var c in e2.Service.Characteristics)
{
Console.WriteLine(string.Format("{0} - isNotifying = {1}", c.ToString(), c.IsNotifying));
if (device.UUID == "2220" && !c.IsNotifying && c.UUID == CBUUID.FromString("2221"))
{
e.Peripheral.SetNotifyValue(true, c);
e.Peripheral.ReadValue(c);
}
if (device.UUID == "FFF0" && !c.IsNotifying && c.UUID == CBUUID.FromString("FFF6"))
{
e.Peripheral.SetNotifyValue(true, c);
e.Peripheral.ReadValue(c);
}
}
};
e.Peripheral.UpdatedCharacterteristicValue += (object sender2, CBCharacteristicEventArgs e2) => {
//Console.WriteLine ("Value of characteristic " + e2.Characteristic + " is " + e2.Characteristic.Value);
if (device.UUID == "2220" && e2.Characteristic.UUID == CBUUID.FromString("2221"))
{
_deviceMap[e.Peripheral].RaiseBeat("foot", 0.5);
}
if (device.UUID == "FFF0" && e2.Characteristic.UUID == CBUUID.FromString("FFF6"))
{
var data = e2.Characteristic.Value;
for (int i = 0; i < Math.Min(8, (int)data.Length); i++)
{
if (data[i] != 48)
{
_deviceMap[e.Peripheral].RaiseBeat(string.Format("pad{0}", i + 1), 0.5);
}
}
}
if (e2.Characteristic.Descriptors != null)
{
foreach (var d in e2.Characteristic.Descriptors)
{
Console.WriteLine(d.ToString());
e.Peripheral.ReadValue(d);
}
}
};
e.Peripheral.UpdatedValue += (object sender2, CBDescriptorEventArgs e2) => {
//Console.WriteLine ("Value of descriptor " + e2.Descriptor + " is " + e2.Descriptor.Value);
};
if (device.Name == "BeatS" && device.UUID == "2220")
{
e.Peripheral.DiscoverServices(new CBUUID[] { CBUUID.FromString("00002220-0000-1000-8000-00805F9B34FB"), CBUUID.FromString("00002221-0000-1000-8000-00805F9B34FB"), CBUUID.FromString("00002902-0000-1000-8000-00805F9B34FB") });
}
else if (device.Name == "BeatBoxers" && device.UUID == "FFF0")
{
e.Peripheral.DiscoverServices(new CBUUID[] { CBUUID.FromString("0000fff0-0000-1000-8000-00805F9B34FB"), CBUUID.FromString("0000fff6-0000-1000-8000-00805F9B34FB"), CBUUID.FromString("00002902-0000-1000-8000-00805F9B34FB") });
}
else
{
_manager.CancelPeripheralConnection(e.Peripheral);
}
}
};
}
