Xamarin / MAUI

using TestXamConnections.Helper;

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

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

        {

            throw new NotImplementedException();

        }

using TestXamConnections.Droid.Receivers;

using TestXamConnections.Helper;

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

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

        private readonly IntentReceiver intentReceiver;

        private readonly Context appContext;

        /* La fonction connect dans le cas du connexion en interne

        *  Est en fait, la configuration de l'IntentReceiver

        */

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

            if (param.ContainsKey(ConnectionConstants.RECEIVABLE_INTENTS_KEY))

            {

                // Récupérations des intents recevable

                List<string> intents = new List<string>();

                intents.AddRange(param[ConnectionConstants.RECEIVABLE_INTENTS_KEY].Split(","));

                // Ajout des intents recevable au IntentFilter

                IntentFilter intentFilter = new IntentFilter();

                intents.ForEach(intent => intentFilter.AddAction(intent));

                appContext.RegisterReceiver(intentReceiver, intentFilter);

            } else

            {

                ConnectionFailedEvent.Invoke(this, null);

            }

            return null;

        }

        public Task<bool> SendCommand(string command)

        {

            Intent launchIntent = appContext.PackageManager.GetLaunchIntentForPackage(command);

            if (launchIntent != null)

            {

                appContext.StartActivity(launchIntent);

                return Task.FromResult(true);

            }

            return Task.FromResult(false);

        }

        public InternConnectionService()

        {

            intentReceiver = new IntentReceiver();

            intentReceiver.OnInternDataReceived += OnInternDataReceived;

            IntentFilter intentFilter = new IntentFilter();

            appContext = Application.Context.ApplicationContext;

        }

        private void OnInternDataReceived(object sender, string value)

        {

            DataReceivedEvent.Invoke(this, new byte[] { 0x06 });

        public EventHandler<string> ConnectionFailedEvent { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

        public Task<bool> Connect(Dictionary<string, string> connectParam)

        public Task<bool> SendCommand(string command)

        {

            throw new NotImplementedException();

        }

                    instance = new WifiConnectionService();

    [Activity(Label = "TestXamConnections", Icon = "@mipmap/myicon", Theme = "@style/MainTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize )]

<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="com.companyname.testxamconnections" android:installLocation="auto">

	<application android:label="TestXamConnections.Android" android:theme="@style/MainTheme"></application>

using Android.App;

using Android.Content;

using Android.OS;

using Android.Runtime;

using Android.Views;

using Android.Widget;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace TestXamConnections.Droid.Receivers

{

    public class IntentReceiver : BroadcastReceiver

    {

        public EventHandler<string> OnInternDataReceived;

        public override void OnReceive(Context context, Intent intent)

        {

            StringBuilder sb = new StringBuilder();

            sb.Append("Action:  " + intent.Action + "\n");

            sb.Append("URI: " + intent.ToUri(IntentUriType.Scheme).ToString() + "\n");

            string log = sb.ToString();

            OnInternDataReceived.Invoke(this, log);

        }

    }

}

			// aapt resource value: 0x7F0C0003

			public const int myicon = 2131492867;

    <foreground android:drawable="@mipmap/myicon" />

    <Compile Include="Receivers\IntentReceiver.cs" />

  <ItemGroup>

    <AndroidResource Include="Resources\mipmap-hdpi\myicon.png" />

  </ItemGroup>

        /* Fonction de connexion à la fonctionnalité cible

         * connectParam : paramètre de connection

         * Pour Bluetooth, addresse MAC

         * Pour connexion interne, les intents recevables

         * --> Ajout à un IntentFilter

         * Déclenche ConnectionFailedEvent si la connection échoue

         */

        Task Connect(Dictionary<string, string> connectParam);

        /*

         * Fonction d'envoi de commande

         * byte[] pour le bluetooth

         * string pour intern

         * Retourne True si la commande s'est bien envoyée

         */

        Task<bool> SendCommand(string command);

        /* Evenement déclenché à la reception de données

         * Renvoi les données sur forme d'un tableau d'octets

         */

        /* Evenement déclenché quand la connexion échoue

         */

        EventHandler<string> ConnectionFailedEvent { get; set; }

using System;

using System.Collections.Generic;

using System.Text;

namespace TestXamConnections.Helper

{

    public static class ConnectionConstants

    {

        public static readonly string MAC_ADDR_KEY = "mac_address";

        public static readonly string LAUNCH_INTENT_KEY = "launch_intent";

        public static readonly string RECEIVABLE_INTENTS_KEY = "receivable_intents";

    }

}

using System;

using System.Collections.Generic;

using System.Text;

using System.Threading.Tasks;

using TestXamConnections.Connection;

using TestXamConnections.Helper;

using Xamarin.Forms;

namespace TestXamConnections.Models

{

    public class AgridentConstants

    {

        public const string ACTION_AGRIDENT_SUCCESS = "fr.coppernic.intent.agridentsuccess";

        public const string ACTION_AGRIDENT_ERROR = "fr.coppernic.intent.agridentfailed";

        public const string ACTION_AGRIDENT_SERVICE_STOP = "fr.coppernic.intent.action.stop.agrident.service";

        public const string ACTION_AGRIDENT_SERVICE_START = "fr.coppernic.intent.action.start.agrident.service";

        public const string ACTION_AGRIDENT_READ = "fr.coppernic.tools.agrident.wedge.READ";

        public const string KEY_BARCODE_DATA = "BarcodeData";

        public const string AGRIDENT_WEDGE = "fr.coppernic.tools.cpcagridentwedge";

    }

    public class AgridentReader

    {

        private IConnectionService ConnectionService { get; set; }

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

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

        public AgridentReader()

        {

            ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionInstance(ConnectionType.Intern);

            ConnectionService.DataReceivedEvent += (s, args) => AgridentDataReceived(args);

        }

        ~AgridentReader()

        {

            ConnectionService.DataReceivedEvent -= (s, args) => AgridentDataReceived(args);

        }

        /* Fonction déclenchée à la reception de données Agrident

         * Trigger l'évènement AgridentDataReceivedEvent

         */

        private void AgridentDataReceived(byte[] args)

        { 

            // Si pas de valeur scannée

            // Evenement error

            if (args[0] == 0x6)

            {

                AgridentNORFIDEvent.Invoke(this, null);

            } 

            // Sinon c'est une valeur rfid

            else

            {

                AgridentDataReceivedEvent.Invoke(this, Encoding.ASCII.GetString(args));

            }

        }

        public async Task<bool> EnableService()

        {

            // Enregistrement des intents recevable par Agrident

            List<string> intentsList = new List<string>()

            {

                AgridentConstants.ACTION_AGRIDENT_SUCCESS,

                AgridentConstants.ACTION_AGRIDENT_ERROR

            };

            string intents = string.Join(',', intentsList);

            // Encapuslation des intents recevables pour envoyer au service de connexion

            Dictionary<string, string> param = new Dictionary<string, string>()

            {

                { ConnectionConstants.RECEIVABLE_INTENTS_KEY, intents }

            };

            await ConnectionService.Connect(param);

            return true;

        }

        public async Task<bool> StartScan()

        {

            return await ConnectionService.SendCommand(AgridentConstants.AGRIDENT_WEDGE);

        }

    }

}

        private IConnectionService ConnectionService { get; set; }

        public EventHandler TeoConnectionFailedEvent { get; set; }

            ConnectionService.ConnectionFailedEvent += TeoConnectionFailed;

            ConnectionService.ConnectionFailedEvent -= TeoConnectionFailed;

        // Fonction appelée si la connexion échoue

        private void TeoConnectionFailed(object sender, string e)

        {

            TeoConnectionFailedEvent.Invoke(this, null) ;

        }

        // Fonction appelée lors de la reception de données par le ConnectionService

        // Connexion à l'appareil en fonction de son addr MAC

        public async Task<bool> ConnectToTeoAsync()

        {

            Dictionary<string, string> param = new Dictionary<string, string>()

            {

                { ConnectionConstants.MAC_ADDR_KEY, MACAddress }

            };

            await ConnectionService.Connect(param);

            return true;

        }

        // Envoi d'une commande passée en argument

        public async Task<bool> SendTeoCommand(TeoCommandType c)

        {

            return await ConnectionService.SendCommand(GetCommandCode(c));

        }

    <EmbeddedResource Update="Views\InternServiceView.xaml">

      <Generator>MSBuild:UpdateDesignTimeXaml</Generator>

    </EmbeddedResource>

using TestXamConnections.Views;

        public async Task NavigateToInternService()

        {

            await Application.Current.MainPage.Navigation.PushAsync(new InternServiceView());

        }

        public ICommand NavigateToInternServiceCommand { private set; get; }

            NavigateToInternServiceCommand = new Command(async () => await NavigateToInternService());

        public CommandItemViewModel(TeoCommandType cmd)

            // Si c'est le teo du bureau

            if (Device.MACAddress == "60:A4:23:EB:FB:5C")

            {

                await Application.Current.MainPage.Navigation.PushAsync(new TeoDeviceView(Device));

            }

using System;

using System.Collections.Generic;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Input;

using TestXamConnections.Models;

using Xamarin.Forms;

namespace TestXamConnections.ViewModels

{

    public class InternServiceViewModel : ViewModelBase

    {

        private bool showRFID;

        private bool showError;

        private AgridentReader agridentReader;

        private string rfidResult;

        private string errorMessage;

        public bool ShowRFID

        {

            get { return showRFID; }

            set { SetProperty(ref showRFID, value); }

        }

        public bool ShowError

        {

            get { return showError; }

            set { SetProperty( ref showError, value); }

        }

        public string RFIDResult

        {

            get { return rfidResult; }

            set { SetProperty(ref rfidResult, value); }

        }

        public string ErrorMessage

        {

            get { return errorMessage; }

            set { SetProperty(ref errorMessage, value); }

        }

        private async Task StartScan()

        {

            ShowError = false;

            ShowRFID = false;

            if (await agridentReader.StartScan() == false)

            {

                ErrorMessage = "Echec du Scan RFID";

            }

        }

        public ICommand StartScanCommand { private set; get; }

        public InternServiceViewModel()

        {

            ShowRFID = false;

            ShowError = false;

            agridentReader = new AgridentReader();

            agridentReader.EnableService().Wait();

            agridentReader.AgridentDataReceivedEvent += OnRFIDResultReceived;

            agridentReader.AgridentNORFIDEvent += OnNoRFIDReceived;

            StartScanCommand = new Command(async () => await StartScan());

        }

        private void OnNoRFIDReceived(object sender, string e)

        {

            ShowError = true;

            ErrorMessage = "Pas de TAG RFID detecté";

        }

        private void OnRFIDResultReceived(object sender, string e)

        {

            ShowRFID = true;

            RFIDResult = e;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Input;

using TestXamConnections.Connection;

using TestXamConnections.Helper;

using TestXamConnections.Models;

using TestXamConnections.Services;

using Xamarin.Forms;

using static TestXamConnections.Models.TeoBalance;

namespace TestXamConnections.ViewModels

{

    public class TeoDeviceViewModel : ViewModelBase

    {

        private bool isConnected;

        private string data;

        private TeoBalance teoScale;

        private bool isVisibleData;

        private bool showError;

        private string errorMessage;

        public bool IsVisibleData

        {

            get { return isVisibleData; }

            set { SetProperty(ref isVisibleData, value); }

        }

        public bool IsConnected

        {

            get { return isConnected; }

            set { SetProperty(ref isConnected, value); }

        }

        public TeoBalance TeoScale

        {

            get { return teoScale; }

            set { SetProperty(ref teoScale, value); }

        }

        public string Data

        {

            get { return data; }

            set { SetProperty(ref data, value); }

        }

        public bool ShowError

        {

            get { return showError; }

            set { SetProperty(ref showError, value); }

        }

        public string ErrorMessage

        {

            get { return errorMessage; }

            set { SetProperty(ref errorMessage, value); }

        }

        public ObservableCollection<CommandItemViewModel> AvailableCommandsList { get; set; }

        public async Task<bool> ConnectToDevice()

        {

            ShowError = false;

            IsConnected = await teoScale.ConnectToTeoAsync();

            return IsConnected;

        }

        public async Task<bool> SendValue(TeoCommandType cmd)

        {

            return await teoScale.SendTeoCommand(cmd);

        }

        public ICommand ConnectToDeviceCommand { private set; get; }

        public ICommand SendValueCommand { private set; get; }

        public TeoDeviceViewModel(Models.Device device)

        {

            TeoScale = new TeoBalance(device);

            ShowError = false;

            IsConnected = false;

            IsVisibleData = false;

            ConnectToDeviceCommand = new Command(async () => await ConnectToDevice());

            SendValueCommand = new Command(async (cmd) => await teoScale.SendTeoCommand((TeoCommandType)cmd));

            TeoScale.TeoDataReceivedEvent = (s, args) => DataReceived(args);

            TeoScale.TeoPeseeReceivedEvent = (s, args) => PeseeReceived(args);

            TeoScale.TeoConnectionFailedEvent = ConnectionFailed;

            // Ajout manuel des commandes

            AvailableCommandsList = new ObservableCollection<CommandItemViewModel>();

            foreach (TeoCommandType _cmd in Enum.GetValues(typeof(TeoCommandType)))

            {

                AvailableCommandsList.Add(new CommandItemViewModel(_cmd));

            }

        }

        private void ConnectionFailed(object sender, EventArgs e)

        {

            IsConnected = false;

            ShowError = true;

            ErrorMessage = "La connexion a échoué";

        }

        public void DataReceived(string args)

        {

            IsVisibleData = true;

            Data += args.Trim() + "\n";

        }

        public void PeseeReceived(ReponsePesee args)

        {

            Data = args.PoidsMesure;

        }

    }

}

    Title="TestXamConnection">

                <xe:BorderView

                    Margin="0,20,0,0"

                    xe:Commands.Tap="{Binding NavigateToInternServiceCommand}"

                    xe:TouchEffect.Color="#0060a8"

                    BackgroundColor="#003266"

                    CornerRadius="65"

                    HorizontalOptions="Center">

                    <StackLayout Padding="15,10">

                        <Label

                            FontSize="16"

                            HorizontalOptions="Center"

                            HorizontalTextAlignment="Center"

                            Text="Service interne"

                            TextColor="#34a9ff" />

                    </StackLayout>

                </xe:BorderView>

<?xml version="1.0" encoding="UTF-8" ?>

<ContentPage

    x:Class="TestXamConnections.Views.InternServiceView"

    xmlns="http://xamarin.com/schemas/2014/forms"

    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"

    xmlns:xe="clr-namespace:XamEffects;assembly=XamEffects">

    <ContentPage.Content>

        <StackLayout BackgroundColor="#001729" VerticalOptions="FillAndExpand">

            <StackLayout VerticalOptions="CenterAndExpand">

                <xe:BorderView

                    Margin="0,20,0,0"

                    xe:Commands.Tap="{Binding StartScanCommand}"

                    xe:TouchEffect.Color="#0060a8"

                    BackgroundColor="#003266"

                    CornerRadius="65"

                    HorizontalOptions="Center">

                    <StackLayout Padding="15,10">

                        <Label

                            FontSize="16"

                            HorizontalOptions="Center"

                            HorizontalTextAlignment="Center"

                            Text="Scan RFID"

                            TextColor="#34a9ff" />

                    </StackLayout>

                </xe:BorderView>

                <Frame

                    Padding="0"

                    BackgroundColor="Transparent"

                    BorderColor="#4f5a64"

                    CornerRadius="5"

                    HasShadow="False"

                    HorizontalOptions="Center"

                    IsVisible="{Binding ShowRFID}"

                    VerticalOptions="CenterAndExpand"

                    WidthRequest="200">

                    <StackLayout Spacing="0">

                        <Label

                            Margin="15"

                            FontSize="15"

                            HorizontalTextAlignment="Center"

                            Text="RFID Scanné"

                            TextColor="#34a9ff" />

                        <BoxView

                            HeightRequest="1"

                            HorizontalOptions="FillAndExpand"

                            Color="#4f5a64" />

                        <Label

                            FontAttributes="Bold"

                            HorizontalTextAlignment="Center"

                            Text="{Binding RFIDResult}"

                            TextColor="White" />

                    </StackLayout>

                </Frame>

                <Frame

                    Padding="0"

                    BackgroundColor="Transparent"

                    BorderColor="#4f5a64"

                    CornerRadius="5"

                    HasShadow="False"

                    HorizontalOptions="Center"

                    IsVisible="{Binding ShowError}"

                    VerticalOptions="CenterAndExpand"

                    WidthRequest="200">

                    <StackLayout Spacing="0">

                        <Label

                            Margin="15"

                            FontSize="15"

                            HorizontalTextAlignment="Center"

                            Text="Erreur"

                            TextColor="#34a9ff" />

                        <BoxView

                            HeightRequest="1"

                            HorizontalOptions="FillAndExpand"

                            Color="#4f5a64" />

                        <Label

                            FontAttributes="Bold"

                            FontSize="Medium"

                            HorizontalTextAlignment="Center"

                            Text="{Binding ErrorMessage}"

                            TextColor="RED" />

                    </StackLayout>

                </Frame>

            </StackLayout>

        </StackLayout>

    </ContentPage.Content>

</ContentPage>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using TestXamConnections.ViewModels;

using Xamarin.Forms;

using Xamarin.Forms.Xaml;

namespace TestXamConnections.Views

{

    [XamlCompilation(XamlCompilationOptions.Compile)]

    public partial class InternServiceView : ContentPage

    {

        public InternServiceView()

        {

            InitializeComponent();

            BindingContext = new InternServiceViewModel();

        }

    }

}

                        IsVisible="{Binding ShowError}"

                        VerticalOptions="CenterAndExpand"

                        WidthRequest="200">

                        <StackLayout Spacing="0">

                            <Label

                                Margin="15"

                                FontSize="15"

                                HorizontalTextAlignment="Center"

                                Text="Erreur"

                                TextColor="#34a9ff" />

                            <BoxView

                                HeightRequest="1"

                                HorizontalOptions="FillAndExpand"

                                Color="#4f5a64" />

                            <Label

                                FontAttributes="Bold"

                                FontSize="Medium"

                                HorizontalTextAlignment="Center"

                                Text="{Binding ErrorMessage}"

                                TextColor="RED" />

                        </StackLayout>

                    </Frame>

                    <Frame

                        Padding="0"

                        BackgroundColor="Transparent"

                        BorderColor="#4f5a64"

                        CornerRadius="5"

                        HasShadow="False"

                        HorizontalOptions="Center"

                                                xe:Commands.Tap="{Binding SendValueCommand, Source={Reference commandsList}}"

                                                xe:Commands.TapParameter="{Binding ToSendCommand}"