How to send data through bluetooth in a WPF application using 32feet.Net

Article
2024-01-17

Scope

This article has the goal to show a solution for send data between devices using a WPF application and the library 32feet.Net.

The solution will implement the MVVM pattern and will use the MVVMLight Toolkit.

Introduction

Bluetooth is an industry-standard protocol that enables wireless connectivity for computers, handheld devices, mobile phones, and other devices.

Bluetooth is designed for use by C/C++ programmers. Some Bluetooth features are available with Windows Sockets. Familiarity with Microsoft Windows networking and Windows Sockets programming is required. The article Bluetooth Programming with Windows Sockets, describes how to use Windows Sockets functions and structures to program a Bluetooth application and provide the Bluetooth connection sample. But in a first attempt it not looks so nice, when our goal is to create a WPF application.

In Codeplex, there is a project called 32feet.NET. This project is a shared-source project to make personal area networking technologies such as Bluetooth, Infrared (IrDA) and more, easily accessible from .NET code. Supports desktop, mobile or embedded systems.

32feet.NET is available on Nugget, and for desktop apps the reference is this 32feet.NET 3.5.0 Nugget Package. Which version we will use in the sample we will create.

Description

The WPF Application will have two "modes": Sender and Receiver. Where the "Sender" has the responsibility to send messages and the "Receiver" will get the messages sent by "Sender".

Let's start!

Creating the project

First create the WPF application in Visual Studio

http://www.saramgsilva.com/wp-content/uploads/2014/10/100714_1225_Howtosendda1.png

After it, install the nugget packages: MVVMLight and 32feet.Net, as following

http://www.saramgsilva.com/wp-content/uploads/2014/10/100714_1225_Howtosendda2.png

Installing MVVM Light Toolkit

http://www.saramgsilva.com/wp-content/uploads/2014/10/100714_1225_Howtosendda3.png

Installing 32feet.Net

http://www.saramgsilva.com/wp-content/uploads/2014/10/100714_1225_Howtosendda4.png

At the end our solution will have the base structure for implement MVVM, that MVVM Light installed through the nuget.

Now we need to define the model for the device that is required when we get the list of the devices around us with bluetooth on.

The Model

The model is defined by the Device class that represent the structure for the device around us. The implementation is

public sealed  class Device
   {
       /// <summary>
       /// Gets or sets the device name.
       /// </summary>
       /// <value>
       /// The device name.
       /// </value>
       public string  DeviceName { get; set; }
 
       /// <summary>
       /// Gets or sets a value indicating whether authenticated.
       /// </summary>
       /// <value>
       /// The authenticated.
       /// </value>
       public bool  IsAuthenticated { get; set; }
 
       /// <summary>
       /// Gets or sets a value indicating whether is connected.
       /// </summary>
       /// <value>
       /// The is connected.
       /// </value>
       public bool  IsConnected { get; set; }
 
       /// <summary>
       /// Gets or sets the nap.
       /// </summary>
       /// <value>
       /// The nap.
       /// </value>
       public ushort  Nap { get; set; }
 
       /// <summary>
       /// Gets or sets the sap.
       /// </summary>
       /// <value>
       /// The sap.
       /// </value>
       public uint  Sap { get; set; }
 
       /// <summary>
       /// Gets or sets the last seen.
       /// </summary>
       /// <value>
       /// The last seen.
       /// </value>
       public DateTime LastSeen { get; set; }
 
       /// <summary>
       /// Gets or sets the last used.
       /// </summary>
       /// <value>
       /// The last used.
       /// </value>
       public DateTime LastUsed { get; set; }
 
       /// <summary>
       /// Gets or sets a value indicating whether remembered.
       /// </summary>
       /// <value>
       /// The remembered.
       /// </value>
       public bool  Remembered { get; set; }
        
       /// <summary>
       /// Gets or sets the device info.
       /// </summary>
       /// <value>
       /// The device info.
       /// </value>
       public BluetoothDeviceInfo DeviceInfo { get; set; }
 
       /// <summary>
       /// Initializes a new instance of the <see cref="Device"/> class.
       /// </summary>
       /// <param name="device_info">
       /// The device_info.
       /// </param>
       public Device(BluetoothDeviceInfo device_info)
       {
           if (device_info != null)
           {
               DeviceInfo = device_info;
               IsAuthenticated = device_info.Authenticated;
               IsConnected = device_info.Connected;
               DeviceName = device_info.DeviceName;
               LastSeen = device_info.LastSeen;
               LastUsed = device_info.LastUsed;
               Nap = device_info.DeviceAddress.Nap;
               Sap = device_info.DeviceAddress.Sap;
               Remembered = device_info.Remembered;
           }
       }
 
       /// <summary>
       /// The to string.
       /// </summary>
       /// <returns>
       /// The <see cref="string"/>.
       /// </returns>
       public override  string ToString()
       {
           return DeviceName;
       }
   }

In a class diagram we will have

http://www.saramgsilva.com/wp-content/uploads/2014/10/100714_1225_Howtosendda5.png

The Services

The services in the application will define the features for the "Sender" and for the "Receiver". These classes will be injected to the view model using the ServiceLocator, and the setup is defined in the ViewModelLocator constructor.

For "Sender" and "Receiver" are connected each other, we need to define a Guid that is set to the ServiceClassId and it is the key for the communication. When "Sender" send a message using the ServiceClassID X only the "Receiver" that know the ServiceClassID X will get the data, any other "Receiver" that know only the ServiceClassID Y, for example, will not receive the data.

The ReceiverBluetoothService

The ReceiverBluetoothService define how the "Receiver" will receive the data from the "Sender". For it is used a thread that will run and will be listening by data.

The implementation for this class is something like

public class  ReceiverBluetoothService : ObservableObject, IDisposable, IReceiverBluetoothService
   {
       private readonly  Guid _serviceClassId;
       private Action<string> _responseAction;
       private BluetoothListener _listener;
       private CancellationTokenSource _cancelSource;
       private bool  _wasStarted;
       private string  _status;
 
       /// <summary>
       /// Initializes a new instance of the <see cref="ReceiverBluetoothService" /> class.
       /// </summary>
       public ReceiverBluetoothService()
       {
          _serviceClassId = new  Guid("0e6114d0-8a2e-477a-8502-298d1ff4b4ba");
       }
 
       /// <summary>
       /// Gets or sets a value indicating whether was started.
       /// </summary>
       /// <value>
       /// The was started.
       /// </value>
       public bool  WasStarted
       {
           get { return _wasStarted; }
           set { Set(() => WasStarted, ref _wasStarted, value); }
       }
        
       /// <summary>
       /// Starts the listening from Senders.
       /// </summary>
       /// <param name="reportAction">
       /// The report Action.
       /// </param>
       public void  Start(Action<string> reportAction)
       {
           WasStarted = true;
           _responseAction = reportAction;
           if (_cancelSource != null && _listener != null)
           {
               Dispose(true);
           }
           _listener = new  BluetoothListener(_serviceClassId)
           {
               ServiceName = "MyService"
           };
           _listener.Start();
 
           _cancelSource = new  CancellationTokenSource();
 
           Task.Run(() => Listener(_cancelSource));
       }
 
       /// <summary>
       /// Stops the listening from Senders.
       /// </summary>
       public void  Stop()
       {
           WasStarted = false;
           _cancelSource.Cancel();
       }
 
       /// <summary>
       /// Listeners the accept bluetooth client.
       /// </summary>
       /// <param name="token">
       /// The token.
       /// </param>
       private void  Listener(CancellationTokenSource token)
       {
           try
           {
               while (true)
               {
                   using (var client = _listener.AcceptBluetoothClient())
                   {
                       if (token.IsCancellationRequested)
                       {
                           return;
                       }
 
                       using (var streamReader = new StreamReader(client.GetStream()))
                       {
                           try
                           {
                               var content = streamReader.ReadToEnd();
                               if (!string.IsNullOrEmpty(content))
                               {
                                   _responseAction(content);
                               }
                           }
                           catch (IOException)
                           {
                               client.Close();
                               break;
                           }
                       }
                   }
               }
           }
           catch (Exception exception)
           {
              // todo handle the exception
              // for the sample it will be ignored
           }
       }
 
       /// <summary>
       /// The dispose.
       /// </summary>
       public void  Dispose()
       {
           Dispose(true);
           GC.SuppressFinalize(this);
       }
 
       /// <summary>
       /// The dispose.
       /// </summary>
       /// <param name="disposing">
       /// The disposing.
       /// </param>
       protected virtual  void Dispose(bool disposing)
       {
           if (disposing)
           {
               if (_cancelSource != null)
               {
                   _listener.Stop();
                   _listener = null;
                   _cancelSource.Dispose();
                   _cancelSource = null;
               }
           }
       }
   }

In the Start method we need to define an action that will be used for report the data received in ViewModel. We could use an event or the Message feature from MVVMLight.

In the Listener method that is running in another thread, we defined a CancellationTokenSource that will be used for stop the process for listening for data.

Note: The "Receiver" allow to start or stop the process for listening data. If a "Sender" send data but the "Receiver" not allow listening, the "Sender" will send the data but "Receiver" will not get it.

The SenderBluetoothService

The SenderBluetoothService define how the "Sender" will send data, but for it is required to select a device that is available. Is not possible to filter for devices that knows the ServiceClassId and the name of the device for where the "Sender" wants to send the data should be known.

The implementation for this class is something like

public sealed  class SenderBluetoothService : ISenderBluetoothService
   {
        private readonly  Guid _serviceClassId;
 
       /// <summary>
       /// Initializes a new instance of the <see cref="SenderBluetoothService"/> class. 
       /// </summary>
       public SenderBluetoothService()
       {
           // this guid is random, only need to match in Sender & Receiver
           // this is like a "key" for the connection!
           _serviceClassId = new  Guid("0e6114d0-8a2e-477a-8502-298d1ff4b4ba");
       }
 
       /// <summary>
       /// Gets the devices.
       /// </summary>
       /// <returns>The list of the devices.</returns>
       public async Task<IList<Device>> GetDevices()
       {
           // for not block the UI it will run in a different threat
           var task = Task.Run(() =>
           {
               var devices = new  List<Device>();
               using (var bluetoothClient = new BluetoothClient())
               {
                   var array = bluetoothClient.DiscoverDevices();
                   var count = array.Length;
                   for (var i = 0; i < count; i++)
                   {
                       devices.Add(new Device(array[i]));
                   }
               }
               return devices;
           });
           return await task;
       }
 
       /// <summary>
       /// Sends the data to the Receiver.
       /// </summary>
       /// <param name="device">The device.</param>
       /// <param name="content">The content.</param>
       /// <returns>If was sent or not.</returns>
       public async Task<bool> Send(Device device, string  content)
       {
           if (device == null)
           {
               throw new  ArgumentNullException("device");
           }
 
           if (string.IsNullOrEmpty(content))
           {
               throw new  ArgumentNullException("content");
           }
 
           // for not block the UI it will run in a different threat
           var task = Task.Run(() =>
           {
               using (var bluetoothClient = new BluetoothClient())
               {
                   try
                   {
                       var ep = new  BluetoothEndPoint(device.DeviceInfo.DeviceAddress, _serviceClassId);
                       
                       // connecting
                       bluetoothClient.Connect(ep);
 
                       // get stream for send the data
                       var bluetoothStream = bluetoothClient.GetStream();
 
                       // if all is ok to send
                       if (bluetoothClient.Connected && bluetoothStream !=  null)
                       {
                           // write the data in the stream
                           var buffer = System.Text.Encoding.UTF8.GetBytes(content);
                           bluetoothStream.Write(buffer, 0, buffer.Length);
                           bluetoothStream.Flush();
                           bluetoothStream.Close();
                           return true;
                       }
                       return false;
                   }
                   catch
                   {
                       // the error will be ignored and the send data will report as not sent
                       // for understood the type of the error, handle the exception
                   }
               }
               return false;
           });
           return await task;
       }
   }

In the Send method, when we are connected to the selected device, we will be available to write in a stream which is received by "Receiver".

The ViewModel

We will define the following view models: ReceiverViewModel, SenderViewModel and MainViewModel that will be binding to the DataContext in ReceiverView, SenderView and MainWindow respectively.