Xamarin / MAUI

using Plugin.BLE;

using Plugin.BLE.Abstractions;

using Plugin.BLE.Abstractions.Contracts;

using Plugin.BLE.Abstractions.EventArgs;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace SICPA_Connexions.Model

{

    public class GestionnaireBLE

    {

        // Class for the Bluetooth adapter

        private readonly IAdapter bluetoothAdapter;

        // Empty list to store BLE devices that can be detected by the Bluetooth adapter

        private List<IDevice> gattDevices;

        private List<IService> servicesList;

        private List<ICharacteristic> charList;

        private ICharacteristic characRead;

        private ICharacteristic characWrite;

        public IDevice DeviceConnected { get; set; }

        public IService SelectedService { get; set; }

        public String RetourBLE { get; set; }

        public GestionnaireBLE()

        {

            gattDevices = new List<IDevice>();

            servicesList = new List<IService>();

            charList = new List<ICharacteristic>(); // List for the available Characteristics on the BLE Device

            bluetoothAdapter = CrossBluetoothLE.Current.Adapter;               // Point bluetoothAdapter to the current adapter on the phone

            bluetoothAdapter.DeviceDiscovered += (sender, foundBleDevice) =>   // When a BLE Device is found, run the small function below to add it to our list

            {

                if (foundBleDevice.Device != null && !string.IsNullOrEmpty(foundBleDevice.Device.Name))

                    gattDevices.Add(foundBleDevice.Device);

            };

        }

        public async Task ScanBLE()

        {

            if (!await PermissionsGrantedAsync())                                                           // Make sure there is permission to use Bluetooth

            {

                await Application.Current.MainPage.DisplayAlert("Persmission requise", "L'application a besoin des permissions locales", "OK");

                return;

            }

            gattDevices.Clear();                                                                           // Also clear the _gattDevices list

            if (!bluetoothAdapter.IsScanning)                                                              // Make sure that the Bluetooth adapter is scanning for devices

            {

                await bluetoothAdapter.StartScanningForDevicesAsync();

            }

            foreach (var device in bluetoothAdapter.ConnectedDevices)                                      // Make sure BLE devices are added to the _gattDevices list

                gattDevices.Add(device);

            foreach (var device in bluetoothAdapter.BondedDevices)

                gattDevices.Add(device);

            foreach (IDevice item in gattDevices)

            {

                if (item.Name.Contains("SICPA"))

                {

                    if (item.State == DeviceState.Connected)                                                // Check first if we are already connected to the BLE Device 

                    {

                        await RecuperationServices(item);

                    }

                    else

                    {

                        try

                        {

                            var connectParameters = new ConnectParameters(false, true);

                            await bluetoothAdapter.ConnectToDeviceAsync(item, connectParameters);          // if we are not connected, then try to connect to the BLE Device selected

                            await RecuperationServices(item);

                        }

                        catch

                        {

                            await Application.Current.MainPage.DisplayAlert("Erreur de connexion", "Erreur de connexion au BLE " + item.Name, "OK");

                        }

                    }

                }

            }

        }

        private async Task<bool> PermissionsGrantedAsync()      // Function to make sure that all the appropriate approvals are in place

        {

            var status = await Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();

            if (status != PermissionStatus.Granted)

            {

                status = await Permissions.RequestAsync<Permissions.LocationWhenInUse>();

            }

            return status == PermissionStatus.Granted;

        }

        private async Task RecuperationServices(IDevice device)

        {

            try

            {

                var servicesListReadOnly = await device.GetServicesAsync();           // Read in the Services available

                servicesList.Clear();

                for (int i = 0; i < servicesListReadOnly.Count; i++)                             // Cycle through the found interfaces

                {

                    servicesList.Add(servicesListReadOnly[i]);                                 // Write to a list of service interfaces

                    if (servicesListReadOnly[i].Id.ToString().Substring(0, 8) == "6e400001")

                    {

                        SelectedService = servicesListReadOnly[i];

                    }

                }

                if (SelectedService != null)

                {

                    var charListReadOnly = await SelectedService.GetCharacteristicsAsync();       // Read in available Characteristics

                    charList.Clear();

                    for (int i = 0; i < charListReadOnly.Count; i++)                               // Cycle through available interfaces

                    {

                        charList.Add(charListReadOnly[i]);                                        // Write to a list of Chars

                        // IMPORTANT: listview cannot cope with entries that have the exact same name. That is why I added "i" to the beginning of the name. If you add the UUID you can delete "i" again.

                        if (charListReadOnly[i].CanRead || charListReadOnly[i].CanUpdate)

                        {

                            characRead = charListReadOnly[i];

                            characRead.ValueUpdated += CharacRead_ValueUpdated;

                        }

                        if (charListReadOnly[i].CanWrite) characWrite = charListReadOnly[i];

                    }

                    DeviceConnected = device;

                }

                else

                {

                    await Application.Current.MainPage.DisplayAlert("Erreur récupération Characteristics", "Erreur récupération Characteristics", "OK");

                }

            }

            catch

            {

                await Application.Current.MainPage.DisplayAlert("Erreur d'initialisation", "Erreur d'initialisation aux services", "OK");

            }

        }

        private void CharacRead_ValueUpdated(object sender, CharacteristicUpdatedEventArgs args)

        {

            var receivedBytes = args.Characteristic.Value;                              // read in received bytes

            Console.WriteLine("byte array: " + BitConverter.ToString(receivedBytes));   // write to the console for debugging

            string charStrBytes = "";                                                                           // in the following section the received bytes will be displayed in different ways (you can select the method you need)

            string charStrUTF8 = "";

            if (receivedBytes != null)

            {

                charStrBytes = "Bytes : " + BitConverter.ToString(receivedBytes);                                // by directly converting the bytes to strings we see the bytes themselves as they are received

                charStrUTF8 = Encoding.UTF8.GetString(receivedBytes, 0, receivedBytes.Length);  // This code interprets the bytes received as ASCII characters

            }

            if (receivedBytes.Length <= 4)

            {                                                                                               // If only 4 or less bytes were received than it could be that an INT was sent. The code here combines the 4 bytes back to an INT

                int char_val = 0;

                for (int i = 0; i < receivedBytes.Length; i++)

                {

                    char_val |= (receivedBytes[i] << i * 8);

                }

                charStrBytes += " | int: " + char_val.ToString();

            }

            RetourBLE = RetourBLE + charStrUTF8;

            //_charStr += Environment.NewLine;                                                                // the NewLine command is added to go to the next line

            //MainThread.BeginInvokeOnMainThread(() =>                                      // as this is a callback function, the "MainThread" needs to be invoked to update the GUI

            //{

            //    Output.Text += _charStr;

            //});

        }

    }

}