/ - Diff - Xamarin / MAUI - Forge DGA

                     else if (_bufferedData[2] == '6')
+                    {
                         PeseeReceivedEvent.Invoke(this, new ReponsePesee("err"));
+                    }
+                    }
                     else
+                    {
                         PeseeReceivedEvent.Invoke(this, new ReponsePesee("err"));
-...
             /// Envoi d'une commande au Teo.
             /// </summary>
             /// <param name="commandType">La commande à envoyer.</param>
             /// <returns></returns>
             /// <returns>true si l'envoi a réussi, false sinon.</returns>
             public async Task<bool> SendCommandAsync(TeoConstants.TeoCommandType cmd)
+            {
                 byte[] commandValue = TeoConstants.TeoCommandValues.GetValueOrDefault(cmd);
                 return await ConnectionService.SendCommand(commandValue);
+            }
             /// <summary>
             /// Envoie d'une commande d'émission de poids au Teo.
             /// </summary>
             /// <returns>true si l'envoi a réussi, false sinon.</returns>
             public async Task<bool> ReadWeightAsync()
+            {
                 byte[] commandValue = TeoConstants.TeoCommandValues.GetValueOrDefault(TeoConstants.TeoCommandType.EmissionPoids);
                 return await ConnectionService.SendCommand(commandValue);
+            }
+        }
+    }

             /// <returns></returns>
             Task<bool> SendCommandAsync(TeoCommandType 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();
+        }
+    }

TestXamConnections/TestXamConnections/Device/Barcode/Honeywell/HoneywellBTReader.cs
1	1	using System;
2	2	using System.Collections.Generic;
	3	using System.Text;
3	4	using System.Threading.Tasks;
4	5	using TestXamConnections.Connection;
5	6	using Xamarin.Forms;
...	...
25	26
26	27	private void BluetoothDataReceived(object sender, byte[] e)
27	28	{
28		BarcodeDataReceivedEvent.Invoke(this, e);
	29	string data = Encoding.ASCII.GetString(e);
	30	BarcodeDataReceivedEvent.Invoke(this, data);
29	31	}
30	32
31		public async Task<bool> ConnectToBTReaderAsync()
	33	public async Task<bool> EnableServiceAsync()
32	34	{
33	35	Dictionary<string, string> param = new Dictionary<string, string>()
34	36	{
...	...
37	39	bool ret = await ConnectionService.Connect(param);
38	40	return ret;
39	41	}
	42
	43	public Task<bool> StartScanAsync()
	44	{
	45	throw new NotImplementedException();
	46	}
40	47	}
41	48	}

     using System;
     using System.Collections.Generic;
     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using Xamarin.Forms;
-...
         public class HoneywellInternReader : IBarcodeReader
+        {
             public DeviceInfo DeviceI { get; set; }
             public IConnectionService ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionServiceInstance(ConnectionType.Intern);
             public IConnectionService ConnectionService { get; set; }
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur Honeywell .
-...
             public HoneywellInternReader(DeviceInfo deviceI)
+            {
                 DeviceI = deviceI;
                 ConnectionService = DependencyService.Get<IConnectionServiceProvider>().GetConnectionServiceInstance(ConnectionType.Intern);
                 ConnectionService.DataReceivedEvent += InternDataReceived;
+            }
             public Task<bool> ConnectToBTReaderAsync()
             private void InternDataReceived(object sender, byte[] intent)
+            {
                 throw new NotImplementedException();
                 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.
             /// </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);
+            }
+        }
+    }

             /// </summary>
             public EventHandler<string> BarcodeDataReceivedEvent { get; set; }
             Task<bool> ConnectToBTReaderAsync();
             /// <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();
+        }
+    }

TestXamConnections/TestXamConnections/Device/RFID/Agrident/AgridentConstants.cs
11	11	public const string ACTION_AGRIDENT_SERVICE_START = "fr.coppernic.intent.action.start.agrident.service";
12	12	public const string ACTION_AGRIDENT_READ = "fr.coppernic.tools.agrident.wedge.READ";
13	13	public const string AGRIDENT_WEDGE = "fr.coppernic.tools.cpcagridentwedge";
	14	public const string KEY_BARCODE_DATA = "BarcodeData";
14	15	}
15	16	}

     using System.Text;
     using System.Threading.Tasks;
     using TestXamConnections.Connection;
     using TestXamConnections.Models;
     using Xamarin.Forms;
     namespace TestXamConnections.Device.RFID.Agrident
-...
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur RFID Agrident.
             /// </summary>
             public EventHandler<string> RFIDDataReceivedEvent { get; set; }
             public EventHandler<ReponseRFID> RFIDDataReceivedEvent { get; set; }
             public AgridentInternReader(DeviceInfo deviceI)
+            {
-...
             private void InternDataReceived(object sender, byte[] intent)
+            {
                 string data = Encoding.ASCII.GetString(intent);
                 switch (data)
                 ReponseRFID ret = new ReponseRFID();
                 if (data == AgridentConstants.ACTION_AGRIDENT_ERROR)
+                {
                     case AgridentConstants.ACTION_AGRIDENT_ERROR:
                         RFIDDataReceivedEvent.Invoke(this, "");
                         break;
                     default:
                         RFIDDataReceivedEvent.Invoke(this, data);
                         break;
                     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 = "";
                     ret.IsoEtendu = data;
                     ret.CodeEtendu = data.Substring(0, 1);
                     ret.TagLu = true;
+                }
                 RFIDDataReceivedEvent.Invoke(this, ret);
+            }
             /// <summary>

     using System;
     using System.Threading.Tasks;
     using TestXamConnections.Models;
     namespace TestXamConnections.Device.RFID
+    {
-...
             /// <summary>
             /// Événement déclenché à la reception de données par le lecteur RFID.
             /// </summary>
             public EventHandler<string> RFIDDataReceivedEvent { get; set; }
             public EventHandler<ReponseRFID> RFIDDataReceivedEvent { get; set; }
             /// <summary>
             /// Initialise la lecture de tag RFID.
             /// </summary>
             /// <returns>true la connexion a réussi, false sinon.</returns>
             /// <returns>true l'init a réussi, false sinon.</returns>
             Task<bool> EnableServiceAsync();
             /// <summary>

+    {
         public class ReponseRFID
+        {
             // TODO (doc JF Bompa)
             /// <summary>
             /// Numéro rfid 15 chiffres
             /// </summary>
             public string IsoRfid { get; set; }
             /// <summary>
             /// Code pays, ou fabriquant, 3 chiffres
             /// </summary>
             public string CodePays { get; set; }
             /// <summary>
             /// Numéro animal 12 chiffres
             /// </summary>
             public string NumeroAnimal { get; set; }
             /// <summary>
             /// Type tag, HDX ou FDX
             /// </summary>
             public string TypeTag { get; set; }
             /// <summary>
             /// Numéro Iso étendu
             /// </summary>
             public string IsoEtendu { get; set; }
             /// <summary>
             /// Code de l'extention de l'Iso etendu
             /// </summary>
             public string CodeEtendu { get; set; }
             /// <summary>
             /// Un tag à été lu
             /// </summary>
             public bool TagLu { get; set; }
+        }
+    }

TestXamConnections/TestXamConnections/ViewModels/BarcodeReaderViewModel.cs
43	43
44	44	public async Task<bool> ConnectToDevice()
45	45	{
46		if (await bcReader.ConnectToBTReaderAsync())
	46	if (await bcReader.EnableServiceAsync())
47	47	{
48	48	ConnectionIndicator = "Connecté";
49	49	CIColor = "Green";
...	...
74	74	bcReader.BarcodeDataReceivedEvent -= DataReceived;
75	75	}
76	76
77		private void DataReceived(object sender, byte[] e)
	77	private void DataReceived(object sender, string receivedData)
78	78	{
79	79	IsVisibleData = true;
80		Data += Encoding.ASCII.GetString(e) + "\n";
	80	Data += receivedData + "\n";
81	81	}
82	82	}
83	83	}

TestXamConnections/TestXamConnections/ViewModels/InternServiceViewModel.cs
3	3	using System.Windows.Input;
4	4	using TestXamConnections.Device.RFID;
5	5	using TestXamConnections.Device.RFID.Agrident;
	6	using TestXamConnections.Models;
6	7	using Xamarin.Forms;
7	8
8	9	namespace TestXamConnections.ViewModels
...	...
77	78	ShowRFID = false;
78	79	}
79	80
80		private void OnRFIDResultReceived(object sender, string e)
	81	private void OnRFIDResultReceived(object sender, ReponseRFID reponseRFID)
81	82	{
82	83	ResetAffichage();
83		if (e == "")
	84	if (reponseRFID.TagLu == false)
84	85	{
85	86	ShowError = true;
86	87	ErrorMessage = "Pas de TAG RFID detecté";
87	88	} else
88	89	{
89	90	ShowRFID = true;
90		RFIDResult = e;
	91	RFIDResult = reponseRFID.IsoEtendu;
91	92	}
92	93	IsScanning = false;
93	94	}

TestXamConnections/TestXamConnections/ViewModels/TeoDeviceViewModel.cs
91	91	{
92	92	// Appel au Balance provider pour récupérer l'item TeoBalancea avec les fonctions d'initiation
93	93	TeoScale = BalanceProvider.GetBalance(Balance.TeoBalance, ConnectionType.Bluetooth, device);
94		TeoScale.SendCommandAsync(TeoConstants.TeoCommandType.EmissionPoids)
	94	TeoScale.SendCommandAsync(TeoConstants.TeoCommandType.EmissionPoids);
95	95	Init();
96	96	}
97	97

                                     Color="#4f5a64" />
                                 <Label
                                     Margin="0,10"
                                     FontAttributes="Bold"
                                     FontSize="17"
                                     HorizontalTextAlignment="Center"
                                     Text="{Binding RFIDResult}"
                                     TextColor="White" />

Xamarin / MAUI

Révision b6f7a16a