BLE device with Unity

Question

I am trying to create a game in Unity3D which connects to bluetooth low energy device that supports the heart rate service and collects the HR data. I have created a WPF library that has been tested on a console application to connect to a BLE device and read the data which works perfectly. However, I do not know how to use this in Unity.

I transferred the library to Unity and had to disable it for the editor as the code uses Windows namespaces which are not supported in the editor. My problem now is how do I debug the code in Unity to check if the library code is working when I run the game. I tried wrapping the code for calling the library namespace and the functions from the library in #if NETFX_CORE, #if ENABLE_WINMD_SUPPORT, #if WINDOWS_UWP and many more but, never got any of the debug logs that I wrote.

Is there any possible solution to this? Any help would be appreciated, thank you!

This is the code for the bluetooth LE connection library:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Windows.Devices.Bluetooth;
using Windows.Devices.Bluetooth.Advertisement;
using Windows.Devices.Bluetooth.GenericAttributeProfile;
using Windows.Devices.Enumeration;
using Windows.Storage.Streams;

namespace BLEHR
{
/// <summary>
/// Wraps and makes use if the <see cref="BluetoothLeAdvertisementWatcher"/>
/// for easier consumption
/// 
/// </summary>
public class BLEAdvertisementWatcher
{
    #region Private Members
    /// <summary>
    /// The underlying bluetooth watcher class
    /// </summary>
    private readonly BluetoothLEAdvertisementWatcher mWatcher;

    /// <summary>
    /// a list of discovered devices
    /// </summary>
    private readonly Dictionary<string, BLEDevice> mDiscoveredDevices = new Dictionary<string, BLEDevice>();

    /// <summary>
    /// The details about Gatt services
    /// </summary>
    private readonly GattServiceIDs mGattServiceIds;

    /// <summary>
    /// a thread lock object for this class
    /// </summary>
    private readonly object mThreadLock = new object();
    #endregion

    #region Public Properties

    /// <summary>
    /// indicates is this watcher is listening for advertisements
    /// </summary>
    public bool Listening => mWatcher.Status == BluetoothLEAdvertisementWatcherStatus.Started;

    /// <summary>
    /// a list of discovered devices
    /// </summary>
    public IReadOnlyCollection<BLEDevice> DiscoveredDevices
    {
        get
        {
            //Clena up any Timeouts
            CleanupTimeouts();
            //Practice Thread safety
            lock (mThreadLock)
            {
                //Convert to readonly list
                return mDiscoveredDevices.Values.ToList().AsReadOnly();
            }
        }
    }

    /// <summary>
    /// The timeout in seconds that a device is removed from the <see cref="DiscoveredDevices"/>
    /// list if it is not re-advertised within this time
    /// </summary>
    public int TimeoutRemoval { get; set; } = 20;

    public int HRValue { get; set; }

    #endregion

    #region Constructor
    /// <summary>
    /// The default constructor
    /// </summary>
    public BLEAdvertisementWatcher(GattServiceIDs gattIds)
    {
        //Null guard
        mGattServiceIds = gattIds ?? throw new ArgumentNullException(nameof(gattIds));
        //Create bluetooth listener
        mWatcher = new BluetoothLEAdvertisementWatcher
        {
            ScanningMode = BluetoothLEScanningMode.Active
        };

        //Listen out for new advertisements
        mWatcher.Received += WatcherAdvertisementReceivedAsync;

        //Listen out for when the watcher stops listening
        mWatcher.Stopped += (watcher, e) =>
        {
            //Inform listeners
            StoppedListening();
        };
    }
    #endregion

    #region Private Methods
    /// <summary>
    /// Listens out for watcher advertisements
    /// </summary>
    /// <param name="sender"> The Watcher </param>
    /// <param name="args">The Arguments </param>
    private async void WatcherAdvertisementReceivedAsync(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs args)
    {
        //cleanup timeouts
        CleanupTimeouts();

        //Get BLE device info
        var device = await GetBLEDeviceAsync(args.BluetoothAddress, args.Timestamp, args.RawSignalStrengthInDBm);

        //Null guard
        if(device == null)
        {
            return;
        }

        //is new discovery?
        var newDiscovery = false;
        var existingName = default(string);

        //Lock your doors
        lock (mThreadLock)
        {
            //Check if this is a new discovery
           newDiscovery= !mDiscoveredDevices.ContainsKey(device.DeviceID);

            //If this is not new...
            if (!newDiscovery)
            {
                //Store the old name
                existingName = mDiscoveredDevices[device.DeviceID].Name;
            }
        }

        //Name changed?
        var nameChanged = 
            //if it already exists
            !newDiscovery &&
            //And is not a blank name
            !string.IsNullOrEmpty(device.Name) &&
            //And the name is different
            existingName != device.Name;

        lock (mThreadLock)
        {
            //add/update the device in the dictionary
            mDiscoveredDevices[device.DeviceID] = device;
        }

        //Inform listeners
        DeviceDiscovered(device);

        //if new discovery...
        if (newDiscovery)
        {
            //Inform listeners
            NewDeviceDiscovered(device);
        }
    }

    /// <summary>
    /// Connects to the BLE device and extracts more information from the
    /// <seealso cref="https://docs.microsoft.com/en-us/uwp/api/windows.devices.bluetooth.bluetoothledevice"/>
    /// </summary>
    /// <param name="address">The BT address of the device to connect to</param>
    /// <param name="broadcastTime">The time the broadcast message was received</param>
    /// <param name="rssi">The signal strength in dB</param>
    /// <returns></returns>
    private async Task<BLEDevice> GetBLEDeviceAsync(ulong address, DateTimeOffset broadcastTime, short rssi)
    {
        //Get bluetooth device info
        var device = await BluetoothLEDevice.FromBluetoothAddressAsync(address).AsTask();

        //Null guard
        if(device == null)
        {
            return null;
        }

        //Get GATT services that are available
        var gatt = await device.GetGattServicesAsync().AsTask();

        //if we have any services..
        if(gatt.Status == GattCommunicationStatus.Success)
        {
            //loop each gatt service
            foreach(var service in gatt.Services)
            {
                //This ID contains the GATT profile assigned number we want!
                //TODO: Get more info and connect
                var gattProfileId = service.Uuid;
            }
        }

        //Return the new device information
        return new BLEDevice
            (
            //Device ID
        deviceID: device.DeviceId,
        //Bluetooth address
        address: device.BluetoothAddress,
        //Device name
        name: device.Name,
        //Broadcast time
        broadcastTime: broadcastTime,
        //Signal strength
        rssi: rssi,
        //Is connected
        connected: device.ConnectionStatus== BluetoothConnectionStatus.Connected,
        //Can Pair?
        canPair: device.DeviceInformation.Pairing.CanPair,
        //Is Paired?
        isPaired: device.DeviceInformation.Pairing.IsPaired
            );


    }

    /// <summary>
    /// Prune any timed out devices that we have not heard off
    /// </summary>
    private void CleanupTimeouts()
    {
        lock (mThreadLock)
        {
            //The date in time that if less than means a device has timed out
            var threshold = DateTime.UtcNow - TimeSpan.FromSeconds(TimeoutRemoval);

            //any devices that have not sent a new broadcast within the time
            mDiscoveredDevices.Where(f => f.Value.BroadcastTime < threshold).ToList().ForEach(device =>
             {
                //remove device
                mDiscoveredDevices.Remove(device.Key);

                //Inform listeners
                DeviceTimeout(device.Value);
             });
        }
    }
    #endregion

    #region Public events
    /// <summary>
    /// Fired when the bluetooth watcher stops listening
    /// </summary>
    public event Action StoppedListening = () => { };

    /// <summary>
    /// Fired when the bluetooth watcher start listening
    /// </summary>
    public event Action StartedListening = () => { };

    /// <summary>
    /// fired when a new device is discovered
    /// </summary>
    public event Action<BLEDevice> NewDeviceDiscovered = (device) => {};

    /// <summary>
    /// fired when a device is discovered
    /// </summary>
    public event Action<BLEDevice> DeviceDiscovered = (device) => { };

    /// <summary>
    /// Fired when a device is removed for timing out
    /// </summary>
    public event Action<BLEDevice> DeviceTimeout = (device) => { };
    #endregion

    #region Public Methods
    /// <summary>
    /// Starts listening for advertisements
    /// </summary>
    public void StartListening()
    {
        lock (mThreadLock)
        {
            //if already listening...
            if (Listening)
            {
                //DO nothing more
                return;
            }
            //Start the underlying watcher
            mWatcher.Start();
        }
        //inform listeners
        StartedListening();
    }

    /// <summary>
    /// Stops listening for advertisements
    /// </summary>
    public void StopListening()
    {
        lock (mThreadLock)
        {
            //if we are not currently listening
            if (!Listening)
            {
                //Do nothing more
                return;
            }

            //Stop listening
            mWatcher.Stop();

            //clear any devices
            mDiscoveredDevices.Clear();
        }
    }

    /// <summary>
    /// Attempts to pair to a BLE device, by ID
    /// </summary>
    /// <param name="deviceID"> The BLE device ID</param>
    /// <returns></returns>
    public async Task PairToDeviceAsync(string deviceID)
    {
        //Get bluetooth device info
        var device = await BluetoothLEDevice.FromIdAsync(deviceID).AsTask();

        //Null guard
        if (device == null)
        {
            //TODO: localize
            throw new ArgumentNullException("");
        }

        //if we are already paired...
        if (device.DeviceInformation.Pairing.IsPaired)
        {
            //un-pair the device
            await device.DeviceInformation.Pairing.UnpairAsync().AsTask();
            return;
        }
        //Try and pair to the device
        device.DeviceInformation.Pairing.Custom.PairingRequested += (sender, args) =>
            {
                //Accept all attempts
                args.Accept(); // <-- could enter a pin in here to accept
            };
        var result = await device.DeviceInformation.Pairing.Custom.PairAsync(DevicePairingKinds.ConfirmOnly).AsTask();

        //Get GATT services that are available
        var gatt = await device.GetGattServicesAsync().AsTask();

        GattDeviceService serviceReq = null;

        GattCharacteristic characteristicReq = null;

        //if we have any services..
        if (gatt.Status == GattCommunicationStatus.Success)
        {
            //loop each gatt service
            foreach (var service in gatt.Services)
            {
                if (service.Uuid == GattServiceUuids.HeartRate)
                {
                    serviceReq = service;
                }
                //This ID contains the GATT profile assigned number we want!
                //TODO: Get more info and connect
                var gattProfileId = service.Uuid;
            }

            var charResults = await serviceReq.GetCharacteristicsAsync().AsTask();

            if(charResults.Status == GattCommunicationStatus.Success)
            {
                foreach (var chars in charResults.Characteristics)
                {
                    if(chars.Uuid == GattCharacteristicUuids.HeartRateMeasurement)
                    {
                        characteristicReq = chars;
                    }
                }

                GattCharacteristicProperties properties = characteristicReq.CharacteristicProperties;

                if (properties.HasFlag(GattCharacteristicProperties.Read))
                {
                    GattReadResult readVal = await characteristicReq.ReadValueAsync().AsTask();

                    if(readVal.Status == GattCommunicationStatus.Success)
                    {
                        var reader = DataReader.FromBuffer(readVal.Value);
                        byte[] input = new byte[reader.UnconsumedBufferLength];
                        reader.ReadBytes(input);
                        HRValue = BitConverter.ToInt32(input, 0);
                    }
                }
            }
        }

        ////Log the result
        //if(result.Status == DevicePairingResultStatus.Paired)
        //{
        //    Console.WriteLine("Pairing successful");
        //}
        //else
        //{
        //    Console.WriteLine($"Pairing failed: {result.Status}");
        //}

    }
    #endregion
}
}

And here is the code I am trying in Unity:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

#if NETFX_CORE
using BLEHR
#endif

public class HRTest : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
#if NETFX_CORE
        var watcher = new BLEAdvertisementWatcher(new GattServiceIDs());
        Debug.Log("Working?");
#endif

    }

    // Update is called once per frame
    void Update()
    {
#if WINDOWS_UWP
        Debug.Log("Connecting");
#endif
    }
}

Answer 1

Debugging with UWP/.Net-Core-only features in Unity seems like an infeasible workflow to me because of the long edit-compile-run cycles. The Unity Editor runs with .Net-Framework and thus can't directly access .Net-Core features. For non-Unity projects there is the possibility to access UWP-API from .Net-Framework via wrappers provided by Windows. But that doesn't work for Unity because of some Unity-specifics ¹ .

BUT there is the possibility to wrap the UWP-calls in a C++ winrt dll and copy the dll to Unity. This way the UWP-API can be also used inside the Unity Editor (eg when pushing the play button). My use case also requires BLE and I uploaded my wrapper in this repo . You're free to use it as a starting point if you want.

One last thing: With .Net version 5 which is also announced for Unity, I guess this should become obsolete as version 5 is said to merge .Net-Framework and .Net-Core.

---

[1] Much information for this answer came from this blog-post by Mike Taulty .