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.Util;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using TestXamConnections.Droid.Utils;

using TestXamConnections.Models;

using TestXamConnections.Connection;

using TestXamConnections.Helper;

namespace TestXamConnections.Droid.Connection

{

    /* Classe permettant d'établir une connection Bluetooth

     * Avec socket RFCOMM connecté au SPP

     */

    public class BluetoothConnectionService : IConnectionService

    {

        private readonly BluetoothAdapter bluetoothAdapter;

        private Thread listeningThread;

        private BluetoothSocket socket;

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

        public BluetoothConnectionService()

        { 

            bluetoothAdapter = BluetoothAdapter.DefaultAdapter;

        }

        // Pour le bluetooth, le paramètre de connection est l'addresse MAC

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

        public async Task Connect(Dictionary<string, string> param)

        {

            try

            {

                // Si jamais on est en train de scanner

                // On annule le scan

                if (bluetoothAdapter.IsDiscovering)

                {

                    bluetoothAdapter.CancelDiscovery();

                }

                if (param.ContainsKey(ConnectionConstants.MAC_ADDR_KEY))

                {

                    BluetoothDevice droidBtDevice = bluetoothAdapter.GetRemoteDevice(param[ConnectionConstants.MAC_ADDR_KEY]);

                    if (droidBtDevice != null)

                    {

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

                        // On ferme la connexion existante

                        if (socket != null)

                        {

                            await CloseConnection();

                        }

                        // 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());

                        listeningThread.Start();

                    }

                }

            }

            catch (Exception)

            {

                Application.SynchronizationContext.Post(_ => { ConnectionFailedEvent.Invoke(this, param[ConnectionConstants.MAC_ADDR_KEY]); }, null);

            }

        }

        public EventHandler<byte[]> DataReceivedEvent { get; set; }

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

        private async Task ListeningAsync()

        {

            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();

                    // Trigger DataReceivedEvent

                    Application.SynchronizationContext.Post(_ => { DataReceivedEvent.Invoke(this, 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);

            }

        }

        private Task<bool> CloseConnection()

        {

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

            return Task.FromResult(true);

        }

        public Task<bool> SendCommand(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 Task<bool> SendCommand(string command)

        {

            throw new NotImplementedException();

        }

    }

}