public void SetPeripheralAndService (CBPeripheral peripheral, CBService service)
{
this._connectedPeripheral = peripheral;
this._currentService = service;
// discover the charactersistics
this._connectedPeripheral.DiscoverCharacteristics(service);
// should be named "DiscoveredCharacteristic"
this._connectedPeripheral.DiscoverCharacteristic += (object sender, CBServiceEventArgs e) => {
Console.WriteLine ("Discovered Characteristic.");
foreach (CBService srv in ((CBPeripheral)sender).Services) {
// if the service has characteristics yet
if(srv.Characteristics != null) {
foreach (var characteristic in service.Characteristics) {
Console.WriteLine("Characteristic: " + characteristic.Description);
this._characteristics.Add (characteristic);
this.CharacteristicsTable.ReloadData();
}
}
}
};
// when a descriptor is dicovered, reload the table.
this._connectedPeripheral.DiscoveredDescriptor += (object sender, CBCharacteristicEventArgs e) => {
foreach (var descriptor in e.Characteristic.Descriptors) {
Console.WriteLine ("Characteristic: " + e.Characteristic.Value + " Discovered Descriptor: " + descriptor);
}
// reload the table
this.CharacteristicsTable.ReloadData();
};
}
public BluetoothServiceHandler(CBPeripheral peripheral)
{
_peripheral = peripheral;
_peripheral.DiscoveredService += OnDiscoveredService;
_peripheral.DiscoverCharacteristic += DiscoveredCharacteristic;
_peripheral.UpdatedNotificationState += OnUpdatedNotificationState;
}
public PeripheralHandler(CBPeripheral peripheral)
{
_peripheral = peripheral;
_serviceHandler = new BluetoothServiceHandler(peripheral);
User = UserStorage.Instance.GetUser(peripheral.Identifier);
_peripheral.UpdatedCharacterteristicValue += OnUpdatedValue;
}
public Service (CBService nativeService, CBPeripheral parentDevice )
{
this._nativeService = nativeService;
this._parentDevice = parentDevice;
}
public override void DiscoveredService(CBPeripheral peripheral, NSError error)
{
System.Console.WriteLine ("Discovered a service");
foreach (var service in peripheral.Services) {
Console.WriteLine (service.ToString ());
peripheral.DiscoverCharacteristics (service);
}
}
public override void DiscoveredCharacteristic(CBPeripheral peripheral, CBService service, NSError error)
{
System.Console.WriteLine ("Discovered characteristics of " + peripheral);
foreach (var c in service.Characteristics) {
Console.WriteLine (c.ToString ());
peripheral.ReadValue (c);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothLE.iOS.Characteristic"/> class.
/// </summary>
/// <param name="peripheral">The native peripheral.</param>
/// <param name="nativeCharacteristic">The native characteristic.</param>
public Characteristic(CBPeripheral peripheral, CBCharacteristic nativeCharacteristic)
{
_peripheral = peripheral;
_peripheral.UpdatedCharacterteristicValue += UpdatedCharacteristicValue;
_nativeCharacteristic = nativeCharacteristic;
_id = _nativeCharacteristic.UUID.ToString().ToGuid();
}
protected virtual void OnConnectionUpdated(CBPeripheral peripheral)
{
var peripheralHandler = _peripheralHandlerList.FirstOrDefault(p => p.Uuid.IsUuidEqual(peripheral.Identifier));
if (peripheralHandler != null)
{
peripheralHandler.User.IsConnected = peripheralHandler.IsConnected;
}
}
NSUuid GetIdentifier(CBPeripheral peripheral)
{
// TODO: https://trello.com/c/t1dmC7hh
if (UIDevice.CurrentDevice.CheckSystemVersion (7, 0))
return peripheral.Identifier;
else
return new NSUuid (); // here we should get UUID instead of Identifier
}
public async Task<PeripheralHandler> CreateHandlerAsync(CBPeripheral peripheral)
{
var handler = new PeripheralHandler(peripheral);
await handler.InitializeAsync();
List.Add(handler);
return handler;
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothLE.iOS.Device"/> class.
/// </summary>
/// <param name="peripheral">Native peripheral.</param>
public Device(CBPeripheral peripheral)
{
_peripheral = peripheral;
_id = DeviceIdentifierToGuid(_peripheral.Identifier);
_peripheral.DiscoveredService += DiscoveredService;
Services = new List<IService>();
}
public Device (CBPeripheral nativeDevice)
{
this._nativeDevice = nativeDevice;
this._nativeDevice.DiscoveredService += (object sender, NSErrorEventArgs e) => {
// why we have to do this check is beyond me. if a service has been discovered, the collection
// shouldn't be null, but sometimes it is. le sigh, apple.
if (this._nativeDevice.Services != null) {
foreach (CBService s in this._nativeDevice.Services)
{
if(!ServiceExists(s))
{
Console.WriteLine ("Device.Discovered Service: " + s.Description);
this._services.Add (new Service(s, this._nativeDevice));
}
}
this.ServicesDiscovered(this, new EventArgs());
}
};
#if __UNIFIED__
// fixed for Unified https://bugzilla.xamarin.com/show_bug.cgi?id=14893
this._nativeDevice.DiscoveredCharacteristic += (object sender, CBServiceEventArgs e) => {
#else
//BUGBUG/TODO: this event is misnamed in our SDK
this._nativeDevice.DiscoverCharacteristic += (object sender, CBServiceEventArgs e) => {
#endif
Console.WriteLine ("Device.Discovered Characteristics.");
//loop through each service, and update the characteristics
foreach (CBService srv in ((CBPeripheral)sender).Services) {
// if the service has characteristics yet
if(srv.Characteristics != null) {
// locate the our new service
foreach (var item in this.Services) {
// if we found the service
if (item.ID == Service.ServiceUuidToGuid(srv.UUID) ) {
item.Characteristics.Clear();
// add the discovered characteristics to the particular service
foreach (var characteristic in srv.Characteristics) {
Console.WriteLine("Device: Characteristic: " + characteristic.Description);
Characteristic newChar = new Characteristic(characteristic, _nativeDevice);
item.Characteristics.Add(newChar);
}
// inform the service that the characteristics have been discovered
// TODO: really, we should just be using a notifying collection.
(item as Service).OnCharacteristicsDiscovered();
}
}
}
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothLE.iOS.Service"/> class.
/// </summary>
/// <param name="peripheral">The native peripheral.</param>
/// <param name="service">The native service.</param>
public Service(CBPeripheral peripheral, CBService service)
{
_peripheral = peripheral;
_nativeService = service;
_id = service.UUID.ToString().ToGuid();
_peripheral.DiscoveredCharacteristic += DiscoveredCharacteristic;
Characteristics = new List<ICharacteristic>();
}
public void Add(CBPeripheral peripheral, string localNameKey)
{
if (_userList.Any(u => u.DeviceUuid.IsUuidEqual(peripheral.Identifier)))
{
return;
}
StoreInList(peripheral);
var user = new User(localNameKey, peripheral.Identifier);
_userList.Add(user);
OnFoundUser(user);
}
public Device(Adapter adapter, CBPeripheral nativeDevice, string name, int rssi, List<AdvertisementRecord> advertisementRecords) : base(adapter)
{
_nativeDevice = nativeDevice;
Id = Guid.ParseExact(_nativeDevice.Identifier.AsString(), "d");
Name = name;
Rssi = rssi;
AdvertisementRecords = advertisementRecords;
// TODO figure out if this is in any way required,
// https://github.com/xabre/xamarin-bluetooth-le/issues/81
//_nativeDevice.UpdatedName += OnNameUpdated;
}
public void SetPeripheralAndService (CBPeripheral peripheral, CBService service)
{
connectedPeripheral = peripheral;
connectedPeripheral.DiscoveredCharacteristic += (sender, e) => {
HandleDiscoveredCharacteristic((CBPeripheral)sender, service);
};
// when a descriptor is dicovered, reload the table.
connectedPeripheral.DiscoveredDescriptor += HandleDiscoveredDescriptor;
// discover the charactersistics
connectedPeripheral.DiscoverCharacteristics(service);
}
void HandleDiscoveredCharacteristic (CBPeripheral peripheral, CBService service)
{
Console.WriteLine ("Discovered Characteristic.");
foreach (CBService srv in peripheral.Services) {
// if the service has characteristics yet
if (srv.Characteristics == null)
continue;
foreach (var characteristic in service.Characteristics) {
Console.WriteLine("Characteristic: {0}", characteristic.Description);
characteristics.Add (characteristic);
}
CharacteristicsTable.ReloadData();
}
}
public HeartRateMonitor (CBCentralManager manager, CBPeripheral peripheral)
{
if (manager == null) {
throw new ArgumentNullException ("manager");
} else if (peripheral == null) {
throw new ArgumentNullException ("peripheral");
}
Location = HeartRateMonitorLocation.Unknown;
Manager = manager;
Peripheral = peripheral;
Peripheral.Delegate = this;
Peripheral.DiscoverServices ();
}
void HandleDiscoveredCharacteristic(CBPeripheral peripheral, CBService service)
{
Console.WriteLine("Discovered Characteristic.");
foreach (CBService srv in peripheral.Services)
{
// if the service has characteristics yet
if (srv.Characteristics == null)
{
continue;
}
foreach (var characteristic in service.Characteristics)
{
Console.WriteLine("Characteristic: {0}", characteristic.Description);
characteristics.Add(characteristic);
}
CharacteristicsTable.ReloadData();
}
}
/// <summary>
/// Occurs when a new service is discovered for the peripheral
/// </summary>
/// <param name="peripheral">Peripheral.</param>
/// <param name="error">Error.</param>
public override void DiscoveredService(CBPeripheral peripheral, NSError error)
{
if (monitor.disposed)
{
return;
}
foreach (var service in peripheral.Services)
{
// Right now limited to POC and Zephyr services
if (service.UUID == BluetoothIdentifiers.POCServiceUUID ||
service.UUID == BluetoothIdentifiers.ZephyrServiceUUID) //GetCBUUID(S_PERIPHERAL_UUID))
{
peripheral.DiscoverCharacteristics(service);
}
Console.WriteLine($"discovered service: {service.UUID}");
}
}
public HeartRateMonitor(CBCentralManager manager, CBPeripheral peripheral)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
else if (peripheral == null)
{
throw new ArgumentNullException("peripheral");
}
Location = HeartRateMonitorLocation.Unknown;
Manager = manager;
Peripheral = peripheral;
Peripheral.Delegate = this;
Peripheral.DiscoverServices();
}
/// <summary>
/// Occurs when the value for a characteristic is updated
/// </summary>
/// <param name="peripheral">Peripheral.</param>
/// <param name="characteristic">Characteristic.</param>
/// <param name="error">Error.</param>
public override void UpdatedCharacterteristicValue(
CBPeripheral peripheral,
CBCharacteristic characteristic, NSError error)
{
DateTime dtNow = DateTime.Now;
/* If we haven't yet reach cutoff time for current update,
* OR we've passed the time after which we want to start updates...*/
if ((dtNow < _dtCurrentUpdateEnd)
||
((dtNow > _dtNextTimeToUpdate)))
{
//Console.WriteLine($"updating value for characteristic {characteristic.UUID}");
if (monitor.disposed || error != null || characteristic.Value == null)
{
return;
}
if (characteristic.UUID == BluetoothIdentifiers.POCHeartRateMeasurementCharacteristicUUID ||
characteristic.UUID == BluetoothIdentifiers.ZephyrHeartRateCharacteristicUUID)
{
monitor.UpdateData(characteristic.Value);
}
// If no update is currently occurring, set flag and update next times
if (!_bUpdateOccurring)
{
// set flag for a new update session
_bUpdateOccurring = true;
// calculate ending time of current session
_dtCurrentUpdateEnd = dtNow.AddSeconds(_secondsToGatherUpdates);
// calculate next starting time based on ending time
_dtNextTimeToUpdate = _dtCurrentUpdateEnd.AddSeconds(_secondsBetweenUpdateProcessing);
}
}
else
{
_bUpdateOccurring = false;
}
}
/// <summary>
/// Occurs when a new characteristic is discovered for aservice
/// </summary>
/// <param name="peripheral">Peripheral.</param>
/// <param name="service">Service.</param>
/// <param name="error">Error.</param>
public override void DiscoveredCharacteristic(CBPeripheral peripheral,
CBService service, NSError error)
{
if (monitor.disposed)
{
return;
}
foreach (var characteristic in service.Characteristics)
{
Console.WriteLine($"discovered characteristic: {characteristic.UUID}");
// Right now limited to POC and Zephyr hear rate characteristics
if (characteristic.UUID == BluetoothIdentifiers.POCHeartRateMeasurementCharacteristicUUID ||
characteristic.UUID == BluetoothIdentifiers.ZephyrHeartRateCharacteristicUUID)
{
service.Peripheral.SetNotifyValue(true, characteristic);
}
}
}
public bool openConnection(string ids)
{
throw new NotImplementedException();
#pragma warning disable CS0162 // Se ha detectado código inaccesible
foreach (CBPeripheral p in discoveredDevices)
#pragma warning restore CS0162 // Se ha detectado código inaccesible
{
if (p.UUID.Equals(CBUUID.FromString(ids)))
{
CurrentPeripheral = p;
}
}
if (CurrentPeripheral != null)
{
bluetoothManager.ConnectPeripheral(CurrentPeripheral);
}
// List<CBPeripheral> peri= bluetoothManager.RetrieveConnectedPeripherals();
// CBPeripheral peripheral = bluetoothManager.RetrievePeripherals(CBUUID.FromString(ids));
//bluetoothManager.ConnectPeripheral
}
public override void UpdatedCharacterteristicValue(CBPeripheral peripheral, CBCharacteristic characteristic, NSError error)
{
lock (_lock)
{
var data = error == null?characteristic.Value?.ToArray() : null;
if (_readCompletionSource != null)
{
_readCompletionSource.TrySetResult(data);
}
else
{
if (error == null)
{
var guid = characteristic.UUID.ToGuid();
_onCharacteristicChanged?.Invoke(guid, data);
}
}
}
}
public void CentralManager_DisconnectedPeripheral(CBCentralManager central, CBPeripheral peripheral, NSError error)
{
Debug.WriteLine("CentralManager_DisconnectedPeripheral");
BoardDisconnected?.Invoke();
if (_requestingDisconnect)
{
// Disconnect was because the user hit the disconnect button.
if (_disconnectionCompletionSource != null)
{
_disconnectionCompletionSource.TrySetResult(true);
}
}
else
{
Reconnect();
}
}
public HeartRateMonitor(CBCentralManager manager, CBPeripheral peripheral)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (peripheral == null)
{
throw new ArgumentNullException(nameof(peripheral));
}
Location = HeartRateMonitorLocation.Unknown;
Manager = manager;
Peripheral = peripheral;
Peripheral.Delegate = new HeartRateMonitorDelegate(this);
Peripheral.DiscoverServices();
}
//TODO Submit Bug to change the methid name to "DiscoveredServices" as this method will fire only when all the Services are discovered
public async override void DiscoveredService(CBPeripheral peripheral, NSError error)
{
base.DiscoveredService(peripheral, error);
foreach (var item in peripheral.Services)
{
var service = new BLEService(item);
if (peripheral.Delegate == null)
{
peripheral.Delegate = this;
}
service.Characteristics = await service.GetCharacteristicsAsync(peripheral, _deviceTaskCompletitionSource.CharacteristicDiscoveryTCS);
servicesList.Add(service);
}
_deviceTaskCompletitionSource.ServicesDiscoveryTCS.SetResult(servicesList);
}
public Device(CBPeripheral nativeDevice)
{
this.nativeDevice = nativeDevice;
this.nativeDevice.DiscoveredService += (object sender, NSErrorEventArgs e) =>
{
if (this.nativeDevice.Services != null)
{
foreach (CBService s in this.nativeDevice.Services)
{
Console.WriteLine("Device.Discovered Service: " + s.Description);
if (!ServiceExists(s))
{
services.Add(new Service(s, this.nativeDevice));
}
}
ServicesDiscovered(this, new EventArgs());
}
};
this.nativeDevice.DiscoveredCharacteristic += NativeDeviceDiscoveredCharacteristic;
}
public BleDeviceiOS(BleManageriOS owner, CBPeripheral peripheral, NSDictionary advertisement, int rssi)
{
Owner = owner;
Peripheral = peripheral;
Name = Peripheral.Name;
ID = Peripheral.Identifier.ToString();
//Todo: check this won't cause memory leak when object get delete.
Peripheral.DiscoveredService += HandleDiscoveredService;
Peripheral.RssiUpdated += HandleRssiUpdated;
Peripheral.UpdatedCharacterteristicValue += HandleUpdatedCharacterteristicValue;
Peripheral.WroteCharacteristicValue += HandleWroteCharacteristicValue;
Peripheral.UpdatedValue += HandleUpdatedValue;
Peripheral.WroteDescriptorValue += HandleWroteDescriptorValue;
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
CBCentralManager manager = new CBCentralManager();
CBPeripheral peripheral =
//manager.ConnectPeripheral(new CBPeripheral())
//var communication = new BluetoothCommunication(@"PPAP09");
//var brick = new Brick(communication);
//var command = new DirectCommand(brick);
//brick.ConnectAsync();
communication.ReportReceived += async(object sender, ReportReceivedEventArgs e) => {
await command.TurnMotorAtSpeedAsync(OutputPort.B, 50);
await command.StartMotorAsync(OutputPort.B);
await Task.Delay(2000);
};
btnForward.TouchUpInside += (sender, e) => {
};
btnBackward.TouchUpInside += (sender, e) => {
};
btnLeft.TouchUpInside += (sender, e) => {
};
btnRight.TouchUpInside += (sender, e) => {
};
btnGo.TouchUpInside += (sender, e) => {
};
btnStop.TouchUpInside += (sender, e) => {
};
}
/// <summary>
/// Connects to known device async.
/// https://developer.apple.com/library/ios/documentation/NetworkingInternetWeb/Conceptual/CoreBluetooth_concepts/BestPracticesForInteractingWithARemotePeripheralDevice/BestPracticesForInteractingWithARemotePeripheralDevice.html
/// </summary>
/// <returns>The to known device async.</returns>
/// <param name="deviceGuid">Device GUID.</param>
public override async Task <IDevice> ConnectToKnownDeviceAsync(Guid deviceGuid,
ConnectParameters connectParameters = default(ConnectParameters),
CancellationToken cancellationToken = default(CancellationToken))
{
// Wait for the PoweredOn state
await this.WaitForState(CBCentralManagerState.PoweredOn, cancellationToken, true);
if (cancellationToken.IsCancellationRequested)
{
throw new TaskCanceledException("ConnectToKnownDeviceAsync cancelled");
}
//FYI attempted to use tobyte array insetead of string but there was a problem with byte ordering Guid->NSUui
NSUuid uuid = new NSUuid(deviceGuid.ToString());
Trace.Message($"[Adapter] Attempting connection to {uuid}");
CBPeripheral[] peripherials = this._centralManager.RetrievePeripheralsWithIdentifiers(uuid);
CBPeripheral peripherial = peripherials.SingleOrDefault();
if (peripherial == null)
{
CBPeripheral[] systemPeripherials = this._centralManager.RetrieveConnectedPeripherals(new CBUUID[0]);
CBUUID cbuuid = CBUUID.FromNSUuid(uuid);
peripherial = systemPeripherials.SingleOrDefault(p => p.UUID.Equals(cbuuid));
if (peripherial == null)
{
throw new Exception($"[Adapter] Device {deviceGuid} not found.");
}
}
Device device = new Device(this, peripherial, this._centralManager, peripherial.Name,
peripherial.RSSI?.Int32Value ?? 0, new List <AdvertisementRecord>());
await this.ConnectToDeviceAsync(device, connectParameters, cancellationToken);
return(device);
}
Task PlatformWriteValue(byte[] value, bool requireResponse)
{
TaskCompletionSource <bool> tcs = null;
CBPeripheral peripheral = Service.Device;
if (requireResponse)
{
tcs = new TaskCompletionSource <bool>();
void handler(object s, CBCharacteristicEventArgs e)
{
if (e.Characteristic == _characteristic)
{
peripheral.WroteCharacteristicValue -= handler;
if (!tcs.Task.IsCompleted)
{
tcs.SetResult(e.Error == null);
}
}
};
peripheral.WroteCharacteristicValue += handler;
}
CBCharacteristicWriteType writeType = requireResponse ? CBCharacteristicWriteType.WithResponse : CBCharacteristicWriteType.WithoutResponse;
if (!requireResponse && !peripheral.CanSendWriteWithoutResponse)
{
writeType = CBCharacteristicWriteType.WithResponse;
}
((CBPeripheral)Service.Device).WriteValue(NSData.FromArray(value), _characteristic, writeType);
if (requireResponse)
{
return(tcs.Task);
}
return(Task.CompletedTask);
}
public void connect(string deviceAddress)
{
if (connectedPeripheral != null)
{
disconnect();
}
var dev = devices.FirstOrDefault((item) => item.Identifier.ToString().ToUpper().Equals(deviceAddress.ToUpper()));
if (dev == null)
{
return;
}
connectedPeripheral = dev; // Make sure we have a reference to this so that it can be canceled while connection is pending
var options = new PeripheralConnectionOptions();
options.NotifyOnConnection = true;
options.NotifyOnDisconnection = true;
options.NotifyOnNotification = true;
centralManager.ConnectPeripheral(dev, options);
}
public void DiscoveredService(CBPeripheral peripheral, NSError error)
{
Debug.WriteLine($"Peripheral_DiscoveredService: {peripheral.Name}");
CBService foundService = null;
foreach (var service in peripheral.Services)
{
if (service.UUID == OWBoard.ServiceUUID.ToCBUUID())
{
foundService = service;
break;
}
}
if (foundService != null)
{
_service = foundService;
_peripheral.DiscoverCharacteristics(_service);
}
}
public void DiscoveredCharacteristic(CBPeripheral peripheral, CBService service, NSError error)
{
Debug.WriteLine("Peripheral_DiscoveredCharacteristic");
//var cbuuid = CBUUID.FromString(characteristicGuid);
foreach (var characteristic in _service.Characteristics)
{
if (_characteristics.ContainsKey(characteristic.UUID))
{
_characteristics[characteristic.UUID] = characteristic;
}
else
{
_characteristics.Add(characteristic.UUID, characteristic);
}
}
_connectionCompletionSource.SetResult(true);
//BoardConnected?.Invoke(null);
//BoardConnected?.Invoke(new OWBoard(_board));
}
private async Task MapDevice(Device device, CBPeripheral nativeDevice)
{
nativeDevice.DiscoveredService += nativeDevice_DiscoveredService;
nativeDevice.DiscoverServices();
await Task.Run(() => _servicesDiscovered.WaitOne(TimeSpan.FromSeconds(10)));
nativeDevice.DiscoveredService -= nativeDevice_DiscoveredService;
_servicesDiscovered.Reset();
foreach (var cbService in nativeDevice.Services)
{
nativeDevice.DiscoveredCharacteristic += nativeDevice_DiscoveredCharacteristic;
nativeDevice.DiscoverCharacteristics(cbService);
await Task.Run(() => _characteristicsDiscovered.WaitOne(TimeSpan.FromSeconds(10)));
nativeDevice.DiscoveredCharacteristic -= nativeDevice_DiscoveredCharacteristic;
_characteristicsDiscovered.Reset();
var service = new Service()
{
Id = BluetoothConverter.ConvertBluetoothLeUuid(cbService.UUID.Uuid),
Device = device,
Characteristics = new List <Characteristic>()
};
foreach (var cbCharacteristic in cbService.Characteristics)
{
var characteristic = await ConvertCharacteristic(cbCharacteristic);
characteristic.Service = service;
service.Characteristics.Add(characteristic);
}
service.Device = device;
device.Services.Add(service);
}
}
Task <byte[]> PlatformReadValue()
{
TaskCompletionSource <byte[]> tcs = new TaskCompletionSource <byte[]>();
CBPeripheral peripheral = Characteristic.Service.Device;
void handler(object s, CBDescriptorEventArgs e)
{
if (e.Descriptor == _descriptor)
{
peripheral.UpdatedValue -= handler;
if (!tcs.Task.IsCompleted)
{
tcs.SetResult(NSObjectToBytes(e.Descriptor.Value));
}
}
};
peripheral.UpdatedValue += handler;
((CBPeripheral)Characteristic.Service.Device).ReadValue(_descriptor);
return(tcs.Task);
}
public FirmwareUpdater(CBPeripheral peripheral)
{
cbCentralManager = new CBCentralManager();
/**
* Creates the DFU Firmware object from a Distribution packet (ZIP).
* returns: The DFU firmware object or `nil` in case of an error.
*/
var path = NSBundle.MainBundle.PathForResource("softdevice_s140", ".zip");
var urlPath = new NSUrl("file://" + path);
dfuFirmware = new DFUFirmware(urlPath);
dfuServiceInitiator = new DFUServiceInitiator(cbCentralManager, peripheral);
dfuServiceInitiator.PacketReceiptNotificationParameter = 12;
dfuServiceInitiator.EnableUnsafeExperimentalButtonlessServiceInSecureDfu = true;
dfuServiceInitiator.ProgressDelegate = new DfuServiceDelegateImplementation(dfuLogger);
dfuServiceInitiator.Logger = new DfuLogger();
dfuServiceInitiator.WithFirmware(dfuFirmware);
}
public BLECBPeripheralWrapper(CBPeripheral peripheral)
{
_wes = new WeakEventSource();
Peripheral = peripheral;
Peripheral.DidOpenL2CapChannel += OnDidOpenL2CapChannel;
Peripheral.DiscoveredCharacteristic += OnDiscoveredCharacteristic;
Peripheral.DiscoveredDescriptor += OnDiscoveredDescriptor;
Peripheral.DiscoveredIncludedService += OnDiscoveredIncludedService;
Peripheral.DiscoveredService += OnDiscoveredService;
Peripheral.InvalidatedService += OnInvalidatedService;
Peripheral.IsReadyToSendWriteWithoutResponse += OnIsReadyToSendWriteWithoutResponse;
Peripheral.ModifiedServices += OnModifiedServices;
Peripheral.RssiRead += OnRssiRead;
Peripheral.RssiUpdated += OnRssiUpdated;
Peripheral.UpdatedCharacterteristicValue += OnUpdatedCharacterteristicValue;
Peripheral.UpdatedName += OnUpdatedName;
Peripheral.UpdatedNotificationState += OnUpdatedNotificationState;
Peripheral.UpdatedValue += OnUpdatedValue;
Peripheral.WroteCharacteristicValue += OnWroteCharacteristicValue;
Peripheral.WroteDescriptorValue += OnWroteDescriptorValue;
}
public void SetPeripheralAndService(CBPeripheral peripheral, CBService service)
{
this._connectedPeripheral = peripheral;
this._currentService = service;
// discover the charactersistics
this._connectedPeripheral.DiscoverCharacteristics(service);
// should be named "DiscoveredCharacteristic"
this._connectedPeripheral.DiscoverCharacteristic += (object sender, CBServiceEventArgs e) => {
Console.WriteLine("Discovered Characteristic.");
foreach (CBService srv in ((CBPeripheral)sender).Services)
{
// if the service has characteristics yet
if (srv.Characteristics != null)
{
foreach (var characteristic in service.Characteristics)
{
Console.WriteLine("Characteristic: " + characteristic.Description);
this._characteristics.Add(characteristic);
this.CharacteristicsTable.ReloadData();
}
}
}
};
// when a descriptor is dicovered, reload the table.
this._connectedPeripheral.DiscoveredDescriptor += (object sender, CBCharacteristicEventArgs e) => {
foreach (var descriptor in e.Characteristic.Descriptors)
{
Console.WriteLine("Characteristic: " + e.Characteristic.Value + " Discovered Descriptor: " + descriptor);
}
// reload the table
this.CharacteristicsTable.ReloadData();
};
}
public override void DiscoverCharacteristic(CBPeripheral peripheral, CBService service, NSError error)
{
if (disposed)
{
return;
}
foreach (var characteristic in service.Characteristics)
{
if (characteristic.UUID == HeartRateMeasurementCharacteristicUUID)
{
service.Peripheral.SetNotifyValue(true, characteristic);
}
else if (characteristic.UUID == BodySensorLocationCharacteristicUUID)
{
service.Peripheral.ReadValue(characteristic);
}
else if (characteristic.UUID == HeartRateControlPointCharacteristicUUID)
{
service.Peripheral.WriteValue(NSData.FromBytes((IntPtr)1, 1),
characteristic, CBCharacteristicWriteType.WithResponse);
}
}
}
private Task <GattService> PlatformGetIncludedServiceAsync(BluetoothUuid service)
{
TaskCompletionSource <GattService> tcs = new TaskCompletionSource <GattService>();
CBPeripheral peripheral = Device;
void handler(object sender, CBServiceEventArgs args)
{
peripheral.DiscoveredIncludedService -= handler;
if (args.Error != null)
{
tcs.SetException(new Exception(args.Error.ToString()));
}
else
{
tcs.SetResult(new GattService(Device, args.Service));
}
}
peripheral.DiscoveredIncludedService += handler;
peripheral.DiscoverIncludedServices(new CBUUID[] { service }, _service);
return(tcs.Task);
}
public Device(CBPeripheral nativeDevice)
{
this.nativeDevice = nativeDevice;
this.nativeDevice.DiscoveredService += (object sender, NSErrorEventArgs e) => {
// why we have to do this check is beyond me. if a service has been discovered, the collection
// shouldn't be null, but sometimes it is. le sigh, apple.
if (this.nativeDevice.Services != null)
{
foreach (CBService s in this.nativeDevice.Services)
{
Console.WriteLine("Device.Discovered Service: " + s.Description);
if (!ServiceExists(s))
{
services.Add(new Service(s, this.nativeDevice));
}
}
ServicesDiscovered(this, new EventArgs());
}
};
this.nativeDevice.DiscoveredCharacteristic += NativeDeviceDiscoveredCharacteristic;
}
public override void RetrievedConnectedPeripherals(CBCentralManager central, CBPeripheral[] peripherals)
{
base.RetrievedConnectedPeripherals(central, peripherals);
}
public override void DiscoveredService (CBPeripheral peripheral, NSError error)
{
if (disposed) {
return;
}
foreach (var service in peripheral.Services) {
if (service.UUID == PeripheralUUID) {
peripheral.DiscoverCharacteristics (service);
}
}
}
//TODO: rename to DisconnectDevice
public void DisconnectPeripheral (CBPeripheral peripheral)
{
_central.CancelPeripheralConnection (peripheral);
}
//Hack: In order for CBPeripheral object not to be deallocated hold it's reference
private void StoreInList(CBPeripheral peripheral)
{
CBPeripheral storedPeripheral;
if (Peripherals.TryGetValue(peripheral.Identifier, out storedPeripheral))
{
if (storedPeripheral.IsUuidEqual(peripheral.Identifier))
{
return;
}
}
Peripherals[peripheral.Identifier] = peripheral;
}
public BluetoothLEDevice(CBCentralManager centralManager, CBPeripheral peripheral)
{
_peripheral = peripheral;
_peripheral.Delegate = this;
_centralManager = centralManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothDevice"/> class.
/// </summary>
/// <param name="device">The device.</param>
public BluetoothDevice(CBPeripheral device)
{
this.device = device;
}
internal DeviceInformation(CBPeripheral peripheral, string name)
{
_peripheral = peripheral;
_name = name;
}
public Characteristic (CBCharacteristic nativeCharacteristic, CBPeripheral parentDevice)
{
this._nativeCharacteristic = nativeCharacteristic;
this._parentDevice = parentDevice;
}
public Service(CBService service, CBPeripheral device)
{
_service = service;
_device = device;
}
public override void UpdatedCharacterteristicValue (CBPeripheral peripheral, CBCharacteristic characteristic, NSError error)
{
if (disposed || error != null || characteristic.Value == null) {
return;
}
if (characteristic.UUID == HeartRateMeasurementCharacteristicUUID) {
UpdateHeartRate (characteristic.Value);
} else if (characteristic.UUID == BodySensorLocationCharacteristicUUID) {
UpdateBodySensorLocation (characteristic.Value);
}
}
private static Guid ParseDeviceGuid(CBPeripheral peripherial)
{
return(Guid.ParseExact(peripherial.Identifier.AsString(), "d"));
}
public override void DiscoveredPeripheral(CBCentralManager central, CBPeripheral peripheral, NSDictionary advertisementData, NSNumber RSSI)
{
base.DiscoveredPeripheral(central, peripheral, advertisementData, RSSI);
}
private static bool ContainsDevice(IEnumerable <IDevice> list, CBPeripheral device)
{
return(list.Any(d => Guid.ParseExact(device.Identifier.AsString(), "d") == d.Id));
}
public override void DiscoveredCharacteristic (CBPeripheral peripheral, CBService service, NSError error)
{
if (disposed) {
return;
}
foreach (var characteristic in service.Characteristics) {
if (characteristic.UUID == HeartRateMeasurementCharacteristicUUID) {
service.Peripheral.SetNotifyValue (true, characteristic);
} else if (characteristic.UUID == BodySensorLocationCharacteristicUUID) {
service.Peripheral.ReadValue (characteristic);
} else if (characteristic.UUID == HeartRateControlPointCharacteristicUUID) {
service.Peripheral.WriteValue (NSData.FromBytes ((IntPtr)1, 1),
characteristic, CBCharacteristicWriteType.WithResponse);
}
}
}
public Device(CBPeripheral nativeDevice)
{
_nativeDevice = nativeDevice;
try
{
_nativeDevice.DiscoveredService += (sender, e) =>
{
// why we have to do this check is beyond me. if a service has been discovered, the collection
// shouldn't be null, but sometimes it is. le sigh, apple.
if (_nativeDevice.Services != null)
{
foreach (var s in _nativeDevice.Services)
{
Console.WriteLine("Device.Discovered Service: " + s.Description);
if (!ServiceExists(s))
{
_services.Add(new Service(s, _nativeDevice));
}
}
if (ServicesDiscovered != null)
{
ServicesDiscovered(this, new EventArgs());
}
}
};
#if __UNIFIED__
// fixed for Unified https://bugzilla.xamarin.com/show_bug.cgi?id=14893
_nativeDevice.DiscoveredCharacteristic += (sender, e) =>
{
#else
//BUGBUG/TODO: this event is misnamed in our SDK
this._nativeDevice.DiscoverCharacteristic += (object sender, CBServiceEventArgs e) => {
#endif
Console.WriteLine("Device.Discovered Characteristics.");
//loop through each service, and update the characteristics
foreach (var srv in ((CBPeripheral)sender).Services)
{
// if the service has characteristics yet
if (srv.Characteristics != null)
{
// locate the our new service
foreach (var item in Services)
{
// if we found the service
if (item.ID == Service.ServiceUuidToGuid(srv.UUID))
{
item.Characteristics.Clear();
// add the discovered characteristics to the particular service
foreach (var characteristic in srv.Characteristics)
{
Console.WriteLine("Characteristic: " + characteristic.Description);
var newChar = new Characteristic(characteristic, _nativeDevice);
item.Characteristics.Add(newChar);
}
// inform the service that the characteristics have been discovered
// TODO: really, we shoul just be using a notifying collection.
var service = item as Service;
if (service != null)
{
service.OnCharacteristicsDiscovered();
}
}
}
}
}
};
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public PeripheralSelectedEventArgs (CBPeripheral peripheral)
{
this._peripheral = peripheral;
}
