Xamarin / MAUI

using Android.App;

using Android.Bluetooth;

using Android.Content;

using Android.OS;

using Android.Runtime;

using Android.Views;

using Android.Widget;

using Java.IO;

using Java.Util;

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using TestBLE.Droid.Receivers;

using TestBLE.Droid.Utils;

using TestBLE.Models;

using TestBLE.Services;

namespace TestBLE.Droid.Services

{

    public class BluetoothService : IBluetoothService

    {

        private List<BluetoothDevice> discoveredDevices = new List<BluetoothDevice>();

        private TaskCompletionSource<bool> scanCompletionSource;

        private BluetoothManager bluetoothManager;

        private BluetoothAdapter bluetoothAdapter;

        private BluetoothReceiver bluetoothReceiver;

        private Thread listeningThread;

        private BluetoothSocket socket;

        private readonly string sppUUID = "00001101-0000-1000-8000-00805f9b34fb";

        private string bufferedData;

        public ObservableCollection<BTDevice> FoundDevices = new ObservableCollection<BTDevice>();

        public BluetoothService()

        {

            FoundDevices = new ObservableCollection<BTDevice>();

            bluetoothAdapter = BluetoothAdapter.DefaultAdapter;

            bluetoothReceiver = new BluetoothReceiver();

            bluetoothReceiver.OnBluetoothDeviceDiscovered += DeviceDiscovered;

            bluetoothReceiver.OnScanFinished += ScanFinished;

            // abonnements du BluetoothReceiver au intent ActionFound Et ActionDiscoveryFinished

            IntentFilter intentFilter = new IntentFilter();

            intentFilter.AddAction(BluetoothDevice.ActionFound);

            intentFilter.AddAction(BluetoothAdapter.ActionDiscoveryFinished);

            intentFilter.AddAction(BluetoothDevice.ActionBondStateChanged);

            Application.Context.RegisterReceiver(bluetoothReceiver, intentFilter);

        }

        public async Task<bool> Connect(BTDevice btDevice)

        {

            try

            {

                // Si jamais on est en train de scanner

                // On annule le scan

                if (bluetoothAdapter.IsDiscovering)

                {

                    bluetoothAdapter.CancelDiscovery();

                }

                BluetoothDevice droidBtDevice = bluetoothAdapter.GetRemoteDevice(btDevice.MACAddress);

                //Android.Bluetooth.BluetoothDevice droidBtDevice = adapter.BondedDevices.FirstOrDefault(x => (x.Address == bluetoothDevice.Address));

                if (droidBtDevice != null)

                {

                    // Si le socket est occupé pour une autre connexion

                    // On ferme la connexion existante

                    if (socket != null)

                    {

                        await Disconnect(btDevice);

                    }

                    // Creation du canal RFCOMM (non sécurisé)

                    socket = droidBtDevice.CreateInsecureRfcommSocketToServiceRecord(UUID.FromString(sppUUID));

                    CancellationTokenSource cts = new CancellationTokenSource();

                    cts.CancelAfter(50000);

                    await socket.ConnectAsync().WithCancellation(cts.Token);

                    if (listeningThread != null) listeningThread.Abort();

                    listeningThread = new Thread(async delagate => await ListeningAsync(btDevice));

                    listeningThread.Start();

                    return true;

                }

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex);

            }

            return false;

        }

        // Fonction d'écoute pour le Thread d'écoute

        private async Task ListeningAsync(BTDevice btDevice)

        {

            try

            {

                byte[] buffer = new byte[1024];

                while (socket.IsConnected)

                {

                    int byteAvailable = await socket.InputStream.ReadAsync(buffer, 0, buffer.Length);

                    // Resize the byte array 

                    byte[] filledBuffer = buffer.Take(byteAvailable).ToArray();

                    Application.SynchronizationContext.Post(_ => { OnDataReceived(filledBuffer); }, null);

                }

            }

            catch (IOException ex)

            {

                System.Diagnostics.Debug.WriteLine(ex);

            }

            catch (ThreadAbortException taEx)

            {

                System.Diagnostics.Debug.WriteLine(taEx);

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex);

            }

        }

        public EventHandler<string> DataReceivedEvent { get; set; }

        private string _bufferedData;

        /* 

         * Fonction appelée à la reception de données

         * Trigger l'evenement DataReceivedEvent

         * 

         * IMPORTANT: Les trames peuvent arriver découpées,

         * Donc les données sont gardées dans un buffer d'envoi

         * nommé _bufferedData

         */

        private void OnDataReceived(byte[] buffer)

        {

            // Si le premier character est 2 (ASCII: STX)

            // Alors c'est le début de la trame.

            if (buffer[0] == 2)

            {

                _bufferedData = "";

                // Si character seul on quitte

                if (buffer.Length == 1)

                {

                    return;

                }

                // On enlève STX

                buffer = buffer.Skip(1).ToArray();

                // On mets le début de la trame dans buffer d'envoi

                _bufferedData += Encoding.ASCII.GetString(buffer);

            }

            // Si le dernier character est 13 (ASCII: CR)

            // Alors la trame est terminée

            if (buffer[^1] == 13)

            {

                // On enlève CR

                buffer = buffer.SkipLast(1).ToArray();

                // Conversion en chaîne de caractères

                // Et on complète le buffer d'envoi

                _bufferedData += Encoding.ASCII.GetString(buffer);

                // Trigger evènement

                DataReceivedEvent.Invoke(this, _bufferedData);

            }

        }

        private void ScanFinished(object sender, string e)

        {

            scanCompletionSource?.SetResult(true);

        }

        private void DeviceDiscovered(object sender, BluetoothDevice e)

        {

            if (discoveredDevices.FirstOrDefault(x => x.Address == e.Address) is null)

            {

                discoveredDevices.Add(e);

                FoundDevices.Add(new BTDevice() { Name = e.Name, MACAddress = e.Address });

            }

        }

        public ObservableCollection<BTDevice> DeviceList { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

        public Task StartScan()

        {

            if (bluetoothAdapter.IsDiscovering)

            {

                return scanCompletionSource.Task;

            }

            scanCompletionSource = new TaskCompletionSource<bool>();

            discoveredDevices.Clear();

            FoundDevices.Clear();

            // Lancement du scan

            bluetoothAdapter.StartDiscovery();

            return scanCompletionSource.Task;

        }

        public Task<bool> Pair(BTDevice bluetoothDevice)

        {

            throw new NotImplementedException();

        }

        public Task<bool> Disconnect(BTDevice bluetoothDevice)

        {

            while (socket.IsConnected) socket.Close();

            return Task.FromResult(true);

        }

        private byte[] hexValuesToByteArray(string[] hexValues)

        {

            byte[] ret = hexValues.Select(value => Convert.ToByte(value, 16)).ToArray();

            return ret;

        }

        public Task<bool> SendHexValues(byte[] hexValues)

        {

            if (socket.IsConnected == false)

            {

                return Task.FromResult(false);

            } else

            {

                // Envoi de la commande

                socket.OutputStream.Write(hexValues, 0, hexValues.Length);

                socket.OutputStream.Flush();

            }

            return Task.FromResult(true);

        }

        public ICollection<BTDevice> GetBondedDevices()

        {

            ICollection<BTDevice> ret = new ObservableCollection<BTDevice>();

            foreach (BluetoothDevice bondedDevice in bluetoothAdapter.BondedDevices)

            {

                BTDevice toAddItem = new BTDevice

                {

                    MACAddress = bondedDevice.Address,

                    Name = bondedDevice.Name

                };

                ret.Add(toAddItem);

            }

            return ret;

        }

    }

}