/ - Diff - Xamarin / MAUI - Forge DGA

TestXamConnections/TestXamConnections.Android/Connection/BluetoothConnectionService.cs
15	15	/* Classe permettant d'établir une connection Bluetooth
16	16	* Avec socket RFCOMM connecté au SPP
17	17	*/
18		public class BluetoothConnectionService : IConnectionService
	18	public class BluetoothConnexionService : IConnexionService
19	19	{
20	20	private readonly BluetoothAdapter bluetoothAdapter;
21	21	private Thread listeningThread;
22	22	private BluetoothSocket socket;
23	23	private readonly string sppUUID = "00001101-0000-1000-8000-00805f9b34fb";
24	24
25		public BluetoothConnectionService()
	25	public BluetoothConnexionService()
26	26	{
27	27	bluetoothAdapter = BluetoothAdapter.DefaultAdapter;
28	28	}
29	29
30	30	// Pour le bluetooth, le paramètre de connection est l'addresse MAC
31		public async Task<bool> Connect(Dictionary<string, string> param)
	31	public async Task<bool> Connexion(Dictionary<string, string> param)
32	32	{
33	33	try
34	34	{
...	...
39	39	_ = bluetoothAdapter.CancelDiscovery();
40	40	}
41	41
42		if (param.ContainsKey(ConnectionConstants.MAC_ADDR_KEY))
	42	if (param.ContainsKey(ConnexionConstantes.MAC_ADDR_KEY))
43	43	{
44		BluetoothDevice droidBtDevice = bluetoothAdapter.GetRemoteDevice(param[ConnectionConstants.MAC_ADDR_KEY]);
	44	BluetoothDevice droidBtDevice = bluetoothAdapter.GetRemoteDevice(param[ConnexionConstantes.MAC_ADDR_KEY]);
45	45	if (droidBtDevice != null)
46	46	{
47	47	// Si le socket est occupé pour une autre connexion
...	...
80	80	return true;
81	81	}
82	82
83		public EventHandler<byte[]> DataReceivedEvent { get; set; }
	83	public EventHandler<byte[]> DonneesRecuesEvent { get; set; }
84	84
85	85	// Fonction d'écoute pour le Thread d'écoute
86	86	private async Task ListeningAsync()
...	...
94	94	// Resize the byte array
95	95	byte[] filledBuffer = buffer.Take(byteAvailable).ToArray();
96	96	// Trigger DataReceivedEvent
97		Application.SynchronizationContext.Post(_ => { DataReceivedEvent.Invoke(this, filledBuffer); }, null);
	97	Application.SynchronizationContext.Post(_ => { DonneesRecuesEvent.Invoke(this, filledBuffer); }, null);
98	98	}
99	99	}
100	100	catch (IOException ex)
...	...
118	118	return Task.FromResult(true);
119	119	}
120	120
121		public Task<bool> SendCommand(byte[] command)
	121	public Task<bool> EnvoiCommande(byte[] command)
122	122	{
123	123
124	124	if (socket.IsConnected == false)

          * Pré-installée sur l'appareil
          * Basée sur filtrage d'intent sur BroadcastReceiver
          */
         public class InternConnectionService : IConnectionService
         public class InternConnexionService : IConnexionService
+        {
             public EventHandler<byte[]> DataReceivedEvent { get; set; }
             public EventHandler<byte[]> DonneesRecuesEvent { 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<bool> Connect(Dictionary<string, string> param)
             public Task<bool> Connexion(Dictionary<string, string> param)
+            {
                 if (param.ContainsKey(ConnectionConstants.RECEIVABLE_INTENTS_KEY))
                 if (param.ContainsKey(ConnexionConstantes.RECEIVABLE_INTENTS_KEY))
+                {
                     // Récupérations des intents recevable sous forme de csv
                     List<string> intents = new List<string>();
                     intents.AddRange(param[ConnectionConstants.RECEIVABLE_INTENTS_KEY].Split(","));
                     intents.AddRange(param[ConnexionConstantes.RECEIVABLE_INTENTS_KEY].Split(","));
                     // Ajout des intents recevable au IntentFilter
                     IntentFilter intentFilter = new IntentFilter();
                     intents.ForEach(intent => intentFilter.AddAction(intent));
-...
                 return Task.FromResult(true);
+            }
             public Task<bool> SendCommand(byte[] commandBytes)
             public Task<bool> EnvoiCommande(byte[] commandBytes)
+            {
                 string command = Encoding.ASCII.GetString(commandBytes);
                 Intent launchIntent = appContext.PackageManager.GetLaunchIntentForPackage(command);
-...
                 return Task.FromResult(false);
+            }
             public InternConnectionService()
             public InternConnexionService()
+            {
                 intentReceiver = new IntentReceiver();
                 intentReceiver.OnIntentReceived += IntentReceived;
-...
+            {
                 switch (recIntent.Action)
+                {
                     case AgridentConstants.ACTION_AGRIDENT_SUCCESS:
                         string readData = recIntent.GetStringExtra(AgridentConstants.KEY_BARCODE_DATA);
                         DataReceivedEvent.Invoke(this, Encoding.ASCII.GetBytes(readData));
                     case AgridentConstantes.ACTION_AGRIDENT_SUCCESS:
                         string readData = recIntent.GetStringExtra(AgridentConstantes.KEY_BARCODE_DATA);
                         DonneesRecuesEvent.Invoke(this, Encoding.ASCII.GetBytes(readData));
                         break;
                     case AgridentConstants.ACTION_AGRIDENT_ERROR:
                         DataReceivedEvent.Invoke(this, Encoding.ASCII.GetBytes(AgridentConstants.ACTION_AGRIDENT_ERROR));
                     case AgridentConstantes.ACTION_AGRIDENT_ERROR:
                         DonneesRecuesEvent.Invoke(this, Encoding.ASCII.GetBytes(AgridentConstantes.ACTION_AGRIDENT_ERROR));
                         break;
                     default:

TestXamConnections/TestXamConnections.Android/Connection/WifiConnectionService.cs
8	8	/* Classe permettant d'établir une connection Wifi
9	9	* NON IMPLEMENTEE
10	10	*/
11		public class WifiConnectionService : IConnectionService
	11	public class WifiConnexionService : IConnexionService
12	12	{
13		public EventHandler<byte[]> DataReceivedEvent { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
	13	public EventHandler<byte[]> DonneesRecuesEvent { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
14	14
15		public Task<bool> Connect(Dictionary<string, string> connectParam)
	15	public Task<bool> Connexion(Dictionary<string, string> connectParam)
16	16	{
17	17	throw new NotImplementedException();
18	18	}
19	19
20		public Task<bool> SendCommand(byte[] hexValues)
	20	public Task<bool> EnvoiCommande(byte[] hexValues)
21	21	{
22	22	throw new NotImplementedException();
23	23	}

     using TestXamConnections.Connection;
     using TestXamConnections.Droid.Connection;
     namespace TestBLE.Droid.Helper
+    {
         public class ConnectionServiceProvider : IConnectionServiceProvider
+        {
             public IConnectionService GetConnectionServiceInstance(ConnectionType ct)
+            {
                 IConnectionService instance = null;
                 switch (ct)
+                {
                     case ConnectionType.Bluetooth:
                         // instance = BluetoothConnectionService.Instance;
                         instance = new BluetoothConnectionService();
                         break;
                     case ConnectionType.Intern:
                         instance = new InternConnectionService();
                         break;
                     case ConnectionType.Wifi:
                         instance = new WifiConnectionService();
                         break;
                     default:
                         break;
+                }
                 return instance;
+            }
+        }
+    }

     using TestXamConnections.Connection;
     using TestXamConnections.Droid.Connection;
     namespace TestBLE.Droid.Helper
+    {
         public class ConnexionServiceFournisseur : IConnexionServiceFournisseur
+        {
             public IConnexionService GetConnectionServiceInstance(ConnexionType ct)
+            {
                 IConnexionService instance = null;
                 switch (ct)
+                {
                     case ConnexionType.Bluetooth:
                         // instance = BluetoothConnectionService.Instance;
                         instance = new BluetoothConnexionService();
                         break;
                     case ConnexionType.Intern:
                         instance = new InternConnexionService();
                         break;
                     case ConnexionType.Wifi:
                         instance = new WifiConnexionService();
                         break;
                     default:
                         break;
+                }
                 return instance;
+            }
+        }
+    }

                 Xamarin.Essentials.Platform.Init(this, savedInstanceState);
                 Forms.Init(this, savedInstanceState);
                 DependencyService.RegisterSingleton<IConnectionServiceProvider>(new ConnectionServiceProvider());
                 DependencyService.RegisterSingleton<IConnexionServiceFournisseur>(new ConnexionServiceFournisseur());
                 DependencyService.RegisterSingleton<IBluetoothService>(new BluetoothService());
                 LoadApplication(new App());
+            }

TestXamConnections/TestXamConnections.Android/Receivers/BluetoothReceiver.cs
17	17	BluetoothDevice foundDevice = intent.GetParcelableExtra(BluetoothDevice.ExtraDevice) as BluetoothDevice;
18	18	if (foundDevice != null)
19	19	{
20		var btDevice = new DeviceInfo
	20	var btDevice = new InfoAppareil
21	21	{
22		MACAddress = foundDevice.Address,
23		Name = foundDevice.Name
	22	AdresseMAC = foundDevice.Address,
	23	Nom = foundDevice.Name
24	24	};
25	25	}
26	26	OnBluetoothDeviceDiscovered.Invoke(this, foundDevice);

TestXamConnections/TestXamConnections.Android/Services/BluetoothService.cs
10	10	{
11	11	private readonly BluetoothAdapter bluetoothAdapter;
12	12
13		public ObservableCollection<DeviceInfo> FoundDevices = new ObservableCollection<DeviceInfo>();
	13	public ObservableCollection<InfoAppareil> FoundDevices = new ObservableCollection<InfoAppareil>();
14	14	public BluetoothService()
15	15	{
16		FoundDevices = new ObservableCollection<DeviceInfo>();
	16	FoundDevices = new ObservableCollection<InfoAppareil>();
17	17	bluetoothAdapter = BluetoothAdapter.DefaultAdapter;
18	18	}
19	19
20		public ICollection<DeviceInfo> GetBondedDevices()
	20	public ICollection<InfoAppareil> GetBondedDevices()
21	21	{
22		ICollection<DeviceInfo> ret = new ObservableCollection<DeviceInfo>();
	22	ICollection<InfoAppareil> ret = new ObservableCollection<InfoAppareil>();
23	23	foreach (BluetoothDevice bondedDevice in bluetoothAdapter.BondedDevices)
24	24	{
25		DeviceInfo toAddItem = new DeviceInfo
	25	InfoAppareil toAddItem = new InfoAppareil
26	26	{
27		MACAddress = bondedDevice.Address,
28		Name = bondedDevice.Name
	27	AdresseMAC = bondedDevice.Address,
	28	Nom = bondedDevice.Name
29	29	};
30	30	ret.Add(toAddItem);
31	31	}

       </ItemGroup>
       <ItemGroup>
         <Compile Include="Connection\BluetoothConnectionService.cs" />
         <Compile Include="Helper\ConnectionServiceProvider.cs" />
         <Compile Include="Helper\ConnexionServiceFournisseur.cs" />
         <Compile Include="Connection\InternConnectionService.cs" />
         <Compile Include="Connection\WifiConnectionService.cs" />
         <Compile Include="MainActivity.cs" />

     namespace TestXamConnections.Connection
+    {
         /// <summary>
         /// Constantes de connexion à utiliser lors de l'utilisation
         /// de la fonction Connect de IConnection Service
         /// </summary>
         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";
+        }
+    }

     namespace TestXamConnections.Connection
+    {
         /// <summary>
         /// Constantes de connexion à utiliser lors de l'utilisation
         /// de la fonction Connect de IConnection Service
         /// </summary>
         public static class ConnexionConstantes
+        {
             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.Threading.Tasks;
     namespace TestXamConnections.Connection
+    {
         public interface IConnectionService
+        {
             /// <summary>
             /// Fonction de connexion à la fonctionnalité cible.
             /// </summary>
             /// <param name="connectParam">Paramètre de connection.\nPour Bluetooth, addresse MAC.\n
             /// Pour connexion interne, les intents recevables (ajoutés à un IntentFilter).</param>
             /// <returns>true si la connexion a réussi, false sinon.</returns>
             Task<bool> Connect(Dictionary<string, string> connectParam);
             /// <summary>
             /// Fonction d'envoi de commande pour le bluetooth
             /// </summary>
             /// <param name="hexValues">Données à envoyer sous forme de tableau d'octets</param>
             /// <returns>true si la commande s'est bien envoyée, false sinon.</returns>
             Task<bool> SendCommand(byte[] hexValues);
             /// <summary>
             /// Événement déclenché à la réception de données. Présente les donénes sous forme d’un tableau d’octets.
             /// </summary>
             EventHandler<byte[]> DataReceivedEvent { get; set; }
+        }
+    }

     namespace TestXamConnections.Connection
+    {
         /// <summary>
         /// Type de connection service à demander.
         /// </summary>
         public enum ConnectionType
+        {
             Bluetooth,
             Intern,
             Wifi
+        }
         public interface IConnectionServiceProvider
+        {
             IConnectionService GetConnectionServiceInstance(ConnectionType ct);
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Threading.Tasks;
     namespace TestXamConnections.Connection
+    {
         public interface IConnexionService
+        {
             /// <summary>
             /// Fonction de connexion à la fonctionnalité cible.
             /// </summary>
             /// <param name="connectParam">Paramètre de connexion.\nPour Bluetooth, addresse MAC.\n
             /// Pour connexion interne, les intents recevables (ajoutés à un IntentFilter).</param>
             /// <returns>true si la connexion a réussi, false sinon.</returns>
             Task<bool> Connexion(Dictionary<string, string> connectParam);
             /// <summary>
             /// Fonction d'envoi de commande pour le bluetooth
             /// </summary>
             /// <param name="hexValues">Données à envoyer sous forme de tableau d'octets</param>
             /// <returns>true si la commande s'est bien envoyée, false sinon.</returns>
             Task<bool> EnvoiCommande(byte[] hexValues);
             /// <summary>
             /// Événement déclenché à la réception de données. Présente les donénes sous forme d’un tableau d’octets.
             /// </summary>
             EventHandler<byte[]> DonneesRecuesEvent { get; set; }
+        }
+    }

     namespace TestXamConnections.Connection
+    {
         /// <summary>
         /// Type de connection service à demander.
         /// </summary>
         public enum ConnexionType
+        {
             Bluetooth,
             Intern,
             Wifi
+        }
         public interface IConnexionServiceFournisseur
+        {
             IConnexionService GetConnectionServiceInstance(ConnexionType ct);
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using TestXamConnections.Connection;
     using TestXamConnections.Device.Balance.Balea;
     namespace TestXamConnections.Device.Balance
+    {
         public enum Balance
+        {
             TeoBalance
+        }
         public static class BalanceFournisseur
+        {
             public static IBalance GetBalance(Balance b, ConnexionType ct, InfoAppareil deviceI)
+            {
                 return b switch
+                {
                     Balance.TeoBalance => new TeoBalance(deviceI),
                     _ => null,
                 };
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using TestXamConnections.Connection;
     using TestXamConnections.Device.Balance.Balea;
     namespace TestXamConnections.Device.Balance
+    {
         public enum Balance
+        {
             TeoBalance
+        }
         public static class BalanceProvider
+        {
             public static IBalance GetBalance(Balance b, ConnectionType ct, DeviceInfo deviceI)
+            {
                 return b switch
+                {
                     Balance.TeoBalance => new TeoBalance(deviceI),
                     _ => null,
                 };
+            }
+        }
+    }

TestXamConnections/TestXamConnections/Device/Balance/Balea/TeoBalance.cs
4	4	using System.Text;
5	5	using System.Threading.Tasks;
6	6	using TestXamConnections.Connection;
7		using TestXamConnections.Models;
8	7	using Xamarin.Forms;
9	8
10	9	namespace TestXamConnections.Device.Balance.Balea
11	10	{
12	11	public class TeoBalance : IBalance
13	12	{
14		public DeviceInfo DeviceI { get; set; }
15		public IConnectionService ConnectionService { get; set; }
16		public EventHandler<ReponsePesee> PeseeReceivedEvent { get; set; }
	13	public InfoAppareil AppareilInfos { get; set; }
	14	public IConnexionService ConnexionService { get; set; }
	15	public EventHandler<ReponsePesee> PeseeRecueEvent { get; set; }
17	16
18		public TeoBalance(DeviceInfo deviceI)
	17	public TeoBalance(InfoAppareil deviceI)
19	18	{
20		DeviceI = deviceI;
21		ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionServiceInstance(ConnectionType.Bluetooth);
22		ConnectionService.DataReceivedEvent += TeoDataReceived;
	19	AppareilInfos = deviceI;
	20	ConnexionService = DependencyService.Get<IConnexionServiceFournisseur>().GetConnectionServiceInstance(ConnexionType.Bluetooth);
	21	ConnexionService.DonneesRecuesEvent += TeoDataReceived;
23	22	}
24	23
25	24	~TeoBalance()
26	25	{
27		ConnectionService.DataReceivedEvent -= TeoDataReceived;
	26	ConnexionService.DonneesRecuesEvent -= TeoDataReceived;
28	27	}
29	28
30	29	/*
...	...
67	66	// Trigger evènement en fonction de la trame
68	67	if (_bufferedData.Length == 12)
69	68	{
70		PeseeReceivedEvent.Invoke(this, new ReponsePesee(_bufferedData));
	69	PeseeRecueEvent.Invoke(this, new ReponsePesee(_bufferedData));
71	70	}
72	71	else if (_bufferedData[2] == '6')
73	72	{
74		PeseeReceivedEvent.Invoke(this, new ReponsePesee("err"));
	73	PeseeRecueEvent.Invoke(this, new ReponsePesee("err"));
75	74	}
76	75	else
77	76	{
78		PeseeReceivedEvent.Invoke(this, new ReponsePesee("err"));
	77	PeseeRecueEvent.Invoke(this, new ReponsePesee("err"));
79	78	}
80	79	}
81	80	}
...	...
85	84	/// Important : le bluetooth doit être activé, la balance allumée et les appareils doivent déjà être appairés.
86	85	/// </summary>
87	86	/// <returns>true si la connection a réussi, false sinon.</returns>
88		public async Task<bool> ConnectToBalanceAsync()
	87	public async Task<bool> ConnexionBalanceAsync()
89	88	{
90	89	Dictionary<string, string> param = new Dictionary<string, string>()
91	90	{
92		{ ConnectionConstants.MAC_ADDR_KEY, DeviceI.MACAddress }
	91	{ ConnexionConstantes.MAC_ADDR_KEY, AppareilInfos.AdresseMAC }
93	92	};
94		return await ConnectionService.Connect(param);
	93	return await ConnexionService.Connexion(param);
95	94	}
96	95
97	96	/// <summary>
...	...
99	98	/// </summary>
100	99	/// <param name="commandType">La commande à envoyer.</param>
101	100	/// <returns>true si l'envoi a réussi, false sinon.</returns>
102		public async Task<bool> SendCommandAsync(TeoConstants.TeoCommandType cmd)
	101	public async Task<bool> EnvoiCommandeAsync(TeoConstantes.TeoCommandeType cmd)
103	102	{
104		byte[] commandValue = TeoConstants.TeoCommandValues.GetValueOrDefault(cmd);
105		return await ConnectionService.SendCommand(commandValue);
	103	byte[] commandValue = TeoConstantes.TeoCommandValues.GetValueOrDefault(cmd);
	104	return await ConnexionService.EnvoiCommande(commandValue);
106	105	}
107	106
108	107	/// <summary>
109	108	/// Envoie d'une commande d'émission de poids au Teo.
110	109	/// </summary>
111	110	/// <returns>true si l'envoi a réussi, false sinon.</returns>
112		public async Task<bool> ReadWeightAsync()
	111	public async Task<bool> LirePeseeAsync()
113	112	{
114		byte[] commandValue = TeoConstants.TeoCommandValues.GetValueOrDefault(TeoConstants.TeoCommandType.EmissionPoids);
115		return await ConnectionService.SendCommand(commandValue);
	113	byte[] commandValue = TeoConstantes.TeoCommandValues.GetValueOrDefault(TeoConstantes.TeoCommandeType.EmissionPoids);
	114	return await ConnexionService.EnvoiCommande(commandValue);
116	115	}
117	116
118	117	}

     using System.Collections.Generic;
     namespace TestXamConnections.Device.Balance.Balea
+    {
         public static class TeoConstantes
+        {
             /// <summary>
             /// Liste des commandes disponibles pour la balance Teo, pour le programme INRAE.
             /// </summary>
             public enum TeoCommandeType
+            {
                 // Voir documentation TEO INRAE
                 // Codes ASCII
                 ModeOrdre,
                 SortieOrdre,
                 EmissionPoids,
                 ModePeseeSimple,
                 SortiePeseeSimple
+            }
             public static readonly Dictionary<TeoCommandeType, string> TeoCommandNames = new Dictionary<TeoCommandeType, string>()
+            {
                 { TeoCommandeType.ModeOrdre,         "Mode attente ordre"        },
                 { TeoCommandeType.SortieOrdre,       "Sortie mode ordre"         },
                 { TeoCommandeType.EmissionPoids,     "Emission poids"            },
                 { TeoCommandeType.ModePeseeSimple,   "Mode simple pesage"        },
                 { TeoCommandeType.SortiePeseeSimple, "Sortie mode simple pesage" }
             };
             public static readonly Dictionary<TeoCommandeType, byte[]> TeoCommandValues = new Dictionary<TeoCommandeType, byte[]>()
+            {
                 { TeoCommandeType.ModeOrdre,         new byte[] { 0x02, 0x61, 0x0D } },
                 { TeoCommandeType.SortieOrdre,       new byte[] { 0x02, 0x6B, 0x0D } },
                 { TeoCommandeType.EmissionPoids,     new byte[] { 0x02, 0x63, 0x0D } },
                 { TeoCommandeType.ModePeseeSimple,   new byte[] { 0x02, 0x62, 0x0D } },
                 { TeoCommandeType.SortiePeseeSimple, new byte[] { 0x02, 0x65, 0x0D } }
             };
+        }
+    }

     using System.Collections.Generic;
     namespace TestXamConnections.Device.Balance.Balea
+    {
         public static class TeoConstants
+        {
             /// <summary>
             /// Liste des commandes disponibles pour la balance Teo, pour le programme INRAE.
             /// </summary>
             public enum TeoCommandType
+            {
                 // Voir documentation TEO INRAE
                 // Codes ASCII
                 ModeOrdre,
                 SortieOrdre,
                 EmissionPoids,
                 ModePeseeSimple,
                 SortiePeseeSimple
+            }
             public static readonly Dictionary<TeoCommandType, string> TeoCommandNames = new Dictionary<TeoCommandType, string>()
+            {
                 { TeoCommandType.ModeOrdre,         "Mode attente ordre"        },
                 { TeoCommandType.SortieOrdre,       "Sortie mode ordre"         },
                 { TeoCommandType.EmissionPoids,     "Emission poids"            },
                 { TeoCommandType.ModePeseeSimple,   "Mode simple pesage"        },
                 { TeoCommandType.SortiePeseeSimple, "Sortie mode simple pesage" }
             };
             public static readonly Dictionary<TeoCommandType, byte[]> TeoCommandValues = new Dictionary<TeoCommandType, byte[]>()
+            {
                 { TeoCommandType.ModeOrdre,         new byte[] { 0x02, 0x61, 0x0D } },
                 { TeoCommandType.SortieOrdre,       new byte[] { 0x02, 0x6B, 0x0D } },
                 { TeoCommandType.EmissionPoids,     new byte[] { 0x02, 0x63, 0x0D } },
                 { TeoCommandType.ModePeseeSimple,   new byte[] { 0x02, 0x62, 0x0D } },
                 { TeoCommandType.SortiePeseeSimple, new byte[] { 0x02, 0x65, 0x0D } }
             };
+        }
+    }

     using System;
     using System.Threading.Tasks;
     using TestXamConnections.Models;
     using static TestXamConnections.Device.Balance.Balea.TeoConstants;
     using static TestXamConnections.Device.Balance.Balea.TeoConstantes;
     namespace TestXamConnections.Device.Balance
+    {
         public interface IBalance : IDevice
         public interface IBalance : IAppareil
+        {
             /// <summary>
             /// Événement déclenché à la reception d'une pesée de la part du Teo.
             /// </summary>
             EventHandler<ReponsePesee> PeseeReceivedEvent { get; set; }
             EventHandler<ReponsePesee> PeseeRecueEvent { get; set; }
             /// <summary>
             /// Permet d’établir une connection bluetooth avec une balance.
             /// Important : le bluetooth doit être activé, la balance allumée et les appareils doivent déjà être appairés.
             /// </summary>
             /// <returns>true si la connection a réussi, false sinon.</returns>
             Task<bool> ConnectToBalanceAsync();
             Task<bool> ConnexionBalanceAsync();
             // <summary>
             /// Envoie d'une commande à la balance.
             /// </summary>
             /// <param name="commandType">La commande à envoyer.</param>
             /// <returns></returns>
             Task<bool> SendCommandAsync(TeoCommandType cmd);
             Task<bool> EnvoiCommandeAsync(TeoCommandeType cmd);
             // <summary>
             /// Envoie d'une commande de pesée simple à la balance.
             /// </summary>
             /// <param name="commandType">La commande à envoyer.</param>
             /// <returns></returns>
             Task<bool> ReadWeightAsync();
             Task<bool> LirePeseeAsync();
+        }
+    }

     using System.Linq;
     namespace TestXamConnections.Device.Balance
+    {
         public class ReponsePesee
+        {
             private bool err;
             /// <summary>
             /// Indicateur si erreur de pesée
             /// </summary>
             public bool Err
+            {
                 get => err;
                 set => err = value;
+            }
             private int numPlateau;
             /// <summary>
             /// Le numéro du plateau.
             /// </summary>
             public int NumPlateau
+            {
                 get => numPlateau;
                 set => numPlateau = value;
+            }
             private int typePlateau;
             /// <summary>
             /// Le type du plateau.
             /// </summary>
             public int TypePlateau
+            {
                 get => typePlateau;
                 set => typePlateau = value;
+            }
             private string poidsMesure;
             /// <summary>
             /// Le poids mesuré, en kilogramme.
             /// </summary>
             public string PoidsMesure
+            {
                 get => poidsMesure;
                 set => poidsMesure = value;
+            }
             private bool estNegatif;
             /// <summary>
             /// Indique si le poids mesurée est négatif. True = poids négatif.
             /// </summary>
             public bool EstNegative
+            {
                 get => estNegatif;
                 set => estNegatif = value;
+            }
             public ReponsePesee(string data)
+            {
                 if (data == "err")
+                {
                     Err = true;
+                }
                 else
+                {
                     // Voir doc Balance Teo INRAE
                     NumPlateau = int.Parse(data[0].ToString());
                     TypePlateau = int.Parse(data[1].ToString());
                     EstNegative = data[4] == '-';
                     PoidsMesure = new string(data.Skip(5).ToArray()).Trim();
+                }
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using TestXamConnections.Connection;
     using TestXamConnections.Device.Barcode.Honeywell;
     namespace TestXamConnections.Device.Barcode
+    {
         public enum BarcodeDevice
+        {
             HoneywellIntern,
             HoneywellBT
+        }
         public static class BarcodeReaderProvider
+        {
             public static IBarcodeReader GetBarcodeReader(BarcodeDevice d, ConnectionType ct, DeviceInfo deviceI)
+            {
                 return d switch
+                {
                     BarcodeDevice.HoneywellIntern => new HoneywellInternReader(deviceI),
                     BarcodeDevice.HoneywellBT => new HoneywellBTReader(deviceI),
                     _ => null,
                 };
+            }
+        }
+    }

     namespace TestXamConnections.Device.Barcode.Honeywell
+    {
         /// <summary>
         /// Constantes utilisées pour la communication avec le module Barcode Honeywell interne au C-One².
         /// </summary>
         public static class HoneyWellConstantes
+        {
             public const string ACTION_SCAN = "fr.coppernic.intent.action.SCAN";
             public const string ACTION_STOP_SCAN = "fr.coppernic.intent.action.STOP";
             public const string ACTION_SCAN_SUCCESS = "fr.coppernic.intent.scansuccess";
             public const string ACTION_SCAN_ERROR = "fr.coppernic.intent.scanfailed";
             public const string HONEYWELL_BARCODE = "fr.coppernic.features.barcode.conen";
+        }
+    }

     namespace TestXamConnections.Device.Barcode.Honeywell
+    {
         /// <summary>
         /// Constantes utilisées pour la communication avec le module Barcode Honeywell interne au C-One².
         /// </summary>
         public static class HoneyWellConstants
+        {
             public const string ACTION_SCAN = "fr.coppernic.intent.action.SCAN";
             public const string ACTION_STOP_SCAN = "fr.coppernic.intent.action.STOP";
             public const string ACTION_SCAN_SUCCESS = "fr.coppernic.intent.scansuccess";
             public const string ACTION_SCAN_ERROR = "fr.coppernic.intent.scanfailed";
             public const string HONEYWELL_BARCODE = "fr.coppernic.features.barcode.conen";
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using Xamarin.Forms;
     namespace TestXamConnections.Device.Barcode.Honeywell
+    {
         public class HoneywellBTReader : IBarcodeReader
+        {
             public DeviceInfo DeviceI { get; set; }
             public IConnectionService ConnectionService { get; set; }
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur de code barre Honeywell.
             /// </summary>
             public EventHandler<string> BarcodeDataReceivedEvent { get; set; }
             public HoneywellBTReader(DeviceInfo device)
+            {
                 DeviceI.Name = device.Name;
                 DeviceI.MACAddress = device.MACAddress;
                 ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionServiceInstance(ConnectionType.Bluetooth);
                 ConnectionService.DataReceivedEvent += BluetoothDataReceived;
+            }
             private void BluetoothDataReceived(object sender, byte[] e)
+            {
                 string data = Encoding.ASCII.GetString(e);
                 BarcodeDataReceivedEvent.Invoke(this, data);
+            }
             public async Task<bool> EnableServiceAsync()
+            {
                 Dictionary<string, string> param = new Dictionary<string, string>()
+                {
                     { ConnectionConstants.MAC_ADDR_KEY, DeviceI.MACAddress }
                 };
                 bool ret = await ConnectionService.Connect(param);
                 return ret;
+            }
             public Task<bool> StartScanAsync()
+            {
                 throw new NotImplementedException();
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using Xamarin.Forms;
     namespace TestXamConnections.Device.Barcode.Honeywell
+    {
         public class HoneywellInternReader : IBarcodeReader
+        {
             public DeviceInfo DeviceI { get; set; }
             public IConnectionService ConnectionService { get; set; }
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur Honeywell .
             /// </summary>
             public EventHandler<string> BarcodeDataReceivedEvent { get; set; }
             public HoneywellInternReader(DeviceInfo deviceI)
+            {
                 DeviceI = deviceI;
                 ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionServiceInstance(ConnectionType.Intern);
                 ConnectionService.DataReceivedEvent += InternDataReceived;
+            }
             private void InternDataReceived(object sender, byte[] intent)
+            {
                 string data = Encoding.ASCII.GetString(intent);
                 data = data == HoneyWellConstants.ACTION_SCAN_ERROR ? "err" : data;
                 BarcodeDataReceivedEvent.Invoke(this, data);
+            }
             /// <summary>
             /// Initialise la lecture de code barre avec lecteur interne Honeywell.
             /// </summary>
             /// <returns>true la connexion a réussi, false sinon.</returns>
             public async Task<bool> EnableServiceAsync()
+            {
                 bool ret;
                 // Enregistrement des intents recevable par Agrident
                 List<string> intentsList = new List<string>()
+                {
                     HoneyWellConstants.ACTION_SCAN_SUCCESS,
                     HoneyWellConstants.ACTION_SCAN_ERROR
                 };
                 string intents = string.Join(',', intentsList);
                 // Encapsulation des intents recevables pour envoyer au service de connexion
                 Dictionary<string, string> param = new Dictionary<string, string>()
+                {
                     { ConnectionConstants.RECEIVABLE_INTENTS_KEY, intents }
                 };
                 ret = await ConnectionService.Connect(param);
                 return ret;
+            }
             /// <summary>
             /// Lance un scan de code barre avec le lecteur Honeywell interne.
             /// Important : Il faut d'abord
             /// </summary>
             /// <returns>true si le scan s'est lancé correctement, false sinon.</returns>
             public async Task<bool> StartScanAsync()
+            {
                 byte[] startIntentBytes = Encoding.ASCII.GetBytes(HoneyWellConstants.HONEYWELL_BARCODE);
                 return await ConnectionService.SendCommand(startIntentBytes);
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using Xamarin.Forms;
     namespace TestXamConnections.Device.Barcode.Honeywell
+    {
         public class HoneywellLecteurBT : ILecteurCodeBarre
+        {
             public InfoAppareil AppareilInfos { get; set; }
             public IConnexionService ConnexionService { get; set; }
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur de code barre Honeywell.
             /// </summary>
             public EventHandler<string> CBDonneesRecuesEvent { get; set; }
             public HoneywellLecteurBT(InfoAppareil device)
+            {
                 AppareilInfos.Nom = device.Nom;
                 AppareilInfos.AdresseMAC = device.AdresseMAC;
                 ConnexionService = DependencyService.Get<IConnexionServiceFournisseur>().GetConnectionServiceInstance(ConnexionType.Bluetooth);
                 ConnexionService.DonneesRecuesEvent += BluetoothDataReceived;
+            }
             private void BluetoothDataReceived(object sender, byte[] e)
+            {
                 string data = Encoding.ASCII.GetString(e);
                 CBDonneesRecuesEvent.Invoke(this, data);
+            }
             public async Task<bool> InitServiceAsync()
+            {
                 Dictionary<string, string> param = new Dictionary<string, string>()
+                {
                     { ConnexionConstantes.MAC_ADDR_KEY, AppareilInfos.AdresseMAC }
                 };
                 bool ret = await ConnexionService.Connexion(param);
                 return ret;
+            }
             public Task<bool> LancerScanAsync()
+            {
                 throw new NotImplementedException();
+            }
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using Xamarin.Forms;
     namespace TestXamConnections.Device.Barcode.Honeywell
+    {
         public class HoneywellLecteurInterne : ILecteurCodeBarre
+        {
             public InfoAppareil AppareilInfos { get; set; }
             public IConnexionService ConnexionService { get; set; }
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur Honeywell .
             /// </summary>
             public EventHandler<string> CBDonneesRecuesEvent { get; set; }
             public HoneywellLecteurInterne(InfoAppareil deviceI)
+            {
                 AppareilInfos = deviceI;
                 ConnexionService = DependencyService.Get<IConnexionServiceFournisseur>().GetConnectionServiceInstance(ConnexionType.Intern);
                 ConnexionService.DonneesRecuesEvent += InternDataReceived;
+            }
             private void InternDataReceived(object sender, byte[] intent)
+            {
                 string data = Encoding.ASCII.GetString(intent);
                 data = data == HoneyWellConstantes.ACTION_SCAN_ERROR ? "err" : data;
                 CBDonneesRecuesEvent.Invoke(this, data);
+            }
             /// <summary>
             /// Initialise la lecture de code barre avec lecteur interne Honeywell.
             /// </summary>
             /// <returns>true la connexion a réussi, false sinon.</returns>
             public async Task<bool> InitServiceAsync()
+            {
                 bool ret;
                 // Enregistrement des intents recevable par Agrident
                 List<string> intentsList = new List<string>()
+                {
                     HoneyWellConstantes.ACTION_SCAN_SUCCESS,
                     HoneyWellConstantes.ACTION_SCAN_ERROR
                 };
                 string intents = string.Join(',', intentsList);
                 // Encapsulation des intents recevables pour envoyer au service de connexion
                 Dictionary<string, string> param = new Dictionary<string, string>()
+                {
                     { ConnexionConstantes.RECEIVABLE_INTENTS_KEY, intents }
                 };
                 ret = await ConnexionService.Connexion(param);
                 return ret;
+            }
             /// <summary>
             /// Lance un scan de code barre avec le lecteur Honeywell interne.
             /// Important : Il faut d'abord
             /// </summary>
             /// <returns>true si le scan s'est lancé correctement, false sinon.</returns>
             public async Task<bool> LancerScanAsync()
+            {
                 byte[] startIntentBytes = Encoding.ASCII.GetBytes(HoneyWellConstantes.HONEYWELL_BARCODE);
                 return await ConnexionService.EnvoiCommande(startIntentBytes);
+            }
+        }
+    }

     using System;
     using System.Threading.Tasks;
     namespace TestXamConnections.Device.Barcode
+    {
         public interface IBarcodeReader : IDevice
+        {
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur de code barre.
             /// </summary>
             public EventHandler<string> BarcodeDataReceivedEvent { get; set; }
             /// <summary>
             /// Initialise la lecture de code barre.
             /// </summary>
             /// <returns>true l'init a réussi, false sinon.</returns>
             Task<bool> EnableServiceAsync();
             /// <summary>
             /// Lance un scan de code barre.
             /// </summary>
             /// <returns>true si le scan s'est lancé correctement, false sinon.</returns>
             Task<bool> StartScanAsync();
+        }
+    }

     using System;
     using System.Threading.Tasks;
     namespace TestXamConnections.Device.Barcode
+    {
         public interface ILecteurCodeBarre : IAppareil
+        {
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur de code barre.
             /// </summary>
             public EventHandler<string> CBDonneesRecuesEvent { get; set; }
             /// <summary>
             /// Initialise la lecture de code barre.
             /// </summary>
             /// <returns>true l'init a réussi, false sinon.</returns>
             Task<bool> InitServiceAsync();
             /// <summary>
             /// Lance un scan de code barre.
             /// </summary>
             /// <returns>true si le scan s'est lancé correctement, false sinon.</returns>
             Task<bool> LancerScanAsync();
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using TestXamConnections.Connection;
     using TestXamConnections.Device.Barcode.Honeywell;
     namespace TestXamConnections.Device.Barcode
+    {
         public enum BarcodeDevice
+        {
             HoneywellIntern,
             HoneywellBT
+        }
         public static class LecteurCodeBarreFournisseur
+        {
             public static ILecteurCodeBarre GetBarcodeReader(BarcodeDevice d, ConnexionType ct, InfoAppareil deviceI)
+            {
                 return d switch
+                {
                     BarcodeDevice.HoneywellIntern => new HoneywellLecteurInterne(deviceI),
                     BarcodeDevice.HoneywellBT => new HoneywellLecteurBT(deviceI),
                     _ => null,
                 };
+            }
+        }
+    }

     namespace TestXamConnections.Device
+    {
         /// <summary>
         /// Représente un appareil caractérisé par un nom et une adresse MAC.
         /// </summary>
         public class DeviceInfo
+        {
             /// <summary>
             /// Le nom de l'appareil.
             /// </summary>
             public string Name { get; set; }
             /// <summary>
             /// L'adresse MAC de l'appareil
             /// </summary>
             public string MACAddress { get; set; }
             public override string ToString()
+            {
                 return Name + ":" + MACAddress;
+            }
+        }
+    }

     using TestXamConnections.Connection;
     namespace TestXamConnections.Device
+    {
         public interface IAppareil
+        {
             InfoAppareil AppareilInfos { get; set; }
             IConnexionService ConnexionService { get; set; }
+        }
+    }

     using TestXamConnections.Connection;
     namespace TestXamConnections.Device
+    {
         public interface IDevice
+        {
             DeviceInfo DeviceI { get; set; }
             IConnectionService ConnectionService { get; set; }
+        }
+    }

     namespace TestXamConnections.Device
+    {
         /// <summary>
         /// Représente un appareil caractérisé par un nom et une adresse MAC.
         /// </summary>
         public class InfoAppareil
+        {
             /// <summary>
             /// Le nom de l'appareil.
             /// </summary>
             public string Nom { get; set; }
             /// <summary>
             /// L'adresse MAC de l'appareil
             /// </summary>
             public string AdresseMAC { get; set; }
             public override string ToString()
+            {
                 return Nom + ":" + AdresseMAC;
+            }
+        }
+    }

     namespace TestXamConnections.Device.RFID.Agrident
+    {
         /// <summary>
         /// Constantes utilisées pour la communication avec le module Agrident Wedge interne au C-One².
         /// </summary>
         public static class AgridentConstantes
+        {
             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 AGRIDENT_WEDGE = "fr.coppernic.tools.cpcagridentwedge";
             public const string KEY_BARCODE_DATA = "BarcodeData";
+        }
+    }

     namespace TestXamConnections.Device.RFID.Agrident
+    {
         /// <summary>
         /// Constantes utilisées pour la communication avec le module Agrident Wedge interne au C-One².
         /// </summary>
         public static 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 AGRIDENT_WEDGE = "fr.coppernic.tools.cpcagridentwedge";
             public const string KEY_BARCODE_DATA = "BarcodeData";
+        }
+    }

     using System;
     using System.Collections.Generic;
     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using TestXamConnections.Models;
     using Xamarin.Forms;
     namespace TestXamConnections.Device.RFID.Agrident
+    {
         /// <summary>
         /// Important: Cette classe est utilisable avec le lecteur agrident interne au C-One.
         /// </summary>
         public class AgridentInternReader : IRFIDReader
+        {
             public DeviceInfo DeviceI { get; set; }
             public IConnectionService ConnectionService { get; set; }
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur RFID Agrident.
             /// </summary>
             public EventHandler<ReponseRFID> RFIDDataReceivedEvent { get; set; }
             public AgridentInternReader(DeviceInfo deviceI)
+            {
                 DeviceI = deviceI;
                 ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionServiceInstance(ConnectionType.Intern);
                 ConnectionService.DataReceivedEvent += InternDataReceived;
+            }
             ~AgridentInternReader()
+            {
                 ConnectionService.DataReceivedEvent -= InternDataReceived;
+            }
             /* Fonction déclenchée à la reception de données Agrident
              * Trigger l'évènement AgridentDataReceivedEvent
              */
             private void InternDataReceived(object sender, byte[] intent)
+            {
                 string data = Encoding.ASCII.GetString(intent);
                 ReponseRFID ret = new ReponseRFID();
                 if (data == AgridentConstants.ACTION_AGRIDENT_ERROR)
+                {
                     ret.IsoRfid = "No Tag";
                     ret.TagLu = false;
                 } else
+                {
                     /* Par défaut le lecteur envoie le numéro sur 16 chiffres
                      * (le code pays peut théoriquement être > 999). Donc on se retrouve avec un 0 devant.
                      * Un paramêtre permet de supprimer l'envoie de ce premier 0.
                      * Mais comme on sait pas si se paramétre est coché ou pas,
                      * on fait en sorte de traiter tjs sur 16 chiffres.
                      */
                     if (data.Length == 15)
+                    {
                         data = "0" + data;
+                    }
                     ret.IsoRfid = data.Substring(1, 15);
                     ret.CodePays = data.Substring(1, 3);
                     ret.NumeroAnimal = data.Substring(4, 12);
                     ret.TypeTag = "";

Xamarin / MAUI

Révision 340558f2