/// <summary>
/// Configure the Bluetooth device to send notifications whenever the Characteristic value changes
/// </summary>
private async Task ConfigureServiceForNotificationsAsync()
{
try
{
// Obtain the characteristic for which notifications are to be received
characteristic = service.GetCharacteristics(CHARACTERISTIC_UUID)[CHARACTERISTIC_INDEX];
// While encryption is not required by all devices, if encryption is supported by the device,
// it can be enabled by setting the ProtectionLevel property of the Characteristic object.
// All subsequent operations on the characteristic will work over an encrypted link.
characteristic.ProtectionLevel = GattProtectionLevel.EncryptionRequired;
// Register the event handler for receiving notifications
characteristic.ValueChanged += Characteristic_ValueChanged;
// In order to avoid unnecessary communication with the device, determine if the device is already
// correctly configured to send notifications.
// By default ReadClientCharacteristicConfigurationDescriptorAsync will attempt to get the current
// value from the system cache and communication with the device is not typically required.
var currentDescriptorValue = await characteristic.ReadClientCharacteristicConfigurationDescriptorAsync();
if ((currentDescriptorValue.Status != GattCommunicationStatus.Success) ||
(currentDescriptorValue.ClientCharacteristicConfigurationDescriptor != CHARACTERISTIC_NOTIFICATION_TYPE))
{
// Set the Client Characteristic Configuration Descriptor to enable the device to send notifications
// when the Characteristic value changes
GattCommunicationStatus status =
await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
CHARACTERISTIC_NOTIFICATION_TYPE);
if (status == GattCommunicationStatus.Unreachable)
{
// Register a PnpObjectWatcher to detect when a connection to the device is established,
// such that the application can retry device configuration.
StartDeviceConnectionWatcher();
}
}
}
catch (Exception e)
{
}
}
/// <summary>
/// Register to be notified when a connection is established to the Bluetooth device
/// </summary>
private void StartDeviceConnectionWatcher()
{
watcher = PnpObject.CreateWatcher(PnpObjectType.DeviceContainer,
new string[] { "System.Devices.Connected" }, String.Empty);
watcher.Updated += DeviceConnection_Updated;
watcher.Start();
}
/// <summary>
/// Invoked when a connection is established to the Bluetooth device
/// </summary>
/// <param name="sender">The watcher object that sent the notification</param>
/// <param name="args">The updated device object properties</param>
private async void DeviceConnection_Updated(PnpObjectWatcher sender, PnpObjectUpdate args)
{
var connectedProperty = args.Properties["System.Devices.Connected"];
bool isConnected = false;
if ((deviceContainerId == args.Id) && Boolean.TryParse(connectedProperty.ToString(), out isConnected) &&
isConnected)
{
var status = await characteristic.WriteClientCharacteristicConfigurationDescriptorAsync(
CHARACTERISTIC_NOTIFICATION_TYPE);
if (status == GattCommunicationStatus.Success)
{
IsServiceInitialized = true;
// Once the Client Characteristic Configuration Descriptor is set, the watcher is no longer required
watcher.Stop();
watcher = null;
}
// Notifying subscribers of connection state updates
if (DeviceConnectionUpdated != null)
{
DeviceConnectionUpdated(isConnected);
}
}
}
/// <summary>
/// Invoked when Windows receives data from your Bluetooth device.
/// </summary>
/// <param name="sender">The GattCharacteristic object whose value is received.</param>
/// <param name="args">The new characteristic value sent by the device.</param>
private void Characteristic_ValueChanged(
GattCharacteristic sender,
GattValueChangedEventArgs args)
{
var data = new byte[args.CharacteristicValue.Length];
DataReader.FromBuffer(args.CharacteristicValue).ReadBytes(data);
// Process the raw data received from the device.
var value = ProcessData(data);
value.Timestamp = args.Timestamp;
lock (datapoints)
{
datapoints.Add(value);
}
if (ValueChangeCompleted != null)
{
ValueChangeCompleted(value);
}
}
/// <summary>
/// Process the raw data received from the device into application usable data,
/// according the the Bluetooth Heart Rate Profile.
/// </summary>
/// <param name="data">Raw data received from the heart rate monitor.</param>
/// <returns>The heart rate measurement value.</returns>
private HeartRateMeasurement ProcessData(byte[] data)
{
// Heart Rate profile defined flag values
const byte HEART_RATE_VALUE_FORMAT = 0x01;
const byte ENERGY_EXPANDED_STATUS = 0x08;
byte currentOffset = 0;
byte flags = data[currentOffset];
bool isHeartRateValueSizeLong = ((flags & HEART_RATE_VALUE_FORMAT) != 0);
bool hasEnergyExpended = ((flags & ENERGY_EXPANDED_STATUS) != 0);
currentOffset++;
ushort heartRateMeasurementValue = 0;
if (isHeartRateValueSizeLong)
{
heartRateMeasurementValue = (ushort)((data[currentOffset + 1] << 8) + data[currentOffset]);
currentOffset += 2;
}
else
{
heartRateMeasurementValue = data[currentOffset];
currentOffset++;
}
// The Heart Rate Bluetooth profile can also contain sensor contact status information,
// and R-Wave interval measurements, which can also be processed here.
// For the purpose of this sample, we don't need to interpret that data.
return new HeartRateMeasurement
{
HeartRateValue = heartRateMeasurementValue,
};
}
}
}
