/SICPA_Connexions/Model/GestionnaireBLE.cs - Annoter - Xamarin / MAUI - Forge DGA

sicpaconnexions / SICPA_Connexions / Model / GestionnaireBLE.cs @ 35f65dee

Historique | Voir | Annoter | Télécharger (10,976 ko)

-e7d061
+using Plugin.BLE;
 using Plugin.BLE.Abstractions;
 using Plugin.BLE.Abstractions.Contracts;
 using Plugin.BLE.Abstractions.EventArgs;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 namespace SICPA_Connexions.Model
+{
     public class GestionnaireBLE
+    {
         // Class for the Bluetooth adapter
         private readonly IAdapter bluetoothAdapter;
         // Empty list to store BLE devices that can be detected by the Bluetooth adapter
         private List<IDevice> gattDevices;
         private List<IService> servicesList;
         private List<ICharacteristic> charList;
         private ICharacteristic characRead;
         private ICharacteristic characWrite;
-f65dee
+        private String tempoLecture;
-d21
+        private String retourBLE;
         public event EventHandler RetourBlEMofifiee;
-e7d061
+        public IDevice DeviceConnected { get; set; }
         public IService SelectedService { get; set; }
-d21
+        public String RetourBLE
+        {
             get
+            {
                 return retourBLE;
+            }
             set
+            {
                 if (retourBLE != value)
+                {
                     retourBLE = value;
                     OnRetourBLEMofifiee(EventArgs.Empty);
+                }
+            }
+        }
         public void OnRetourBLEMofifiee(EventArgs e)
+        {
             RetourBlEMofifiee?.Invoke(this, e);
+        }
-e7d061
+            ajournaux
         public GestionnaireBLE()
+        {
             gattDevices = new List<IDevice>();
             servicesList = new List<IService>();
             charList = new List<ICharacteristic>(); // List for the available Characteristics on the BLE Device
             bluetoothAdapter = CrossBluetoothLE.Current.Adapter;               // Point bluetoothAdapter to the current adapter on the phone
             bluetoothAdapter.DeviceDiscovered += (sender, foundBleDevice) =>   // When a BLE Device is found, run the small function below to add it to our list
+            {
                 if (foundBleDevice.Device != null && !string.IsNullOrEmpty(foundBleDevice.Device.Name))
                     gattDevices.Add(foundBleDevice.Device);
             };
+        }
         public async Task ScanBLE()
+        {
             if (!await PermissionsGrantedAsync())                                                           // Make sure there is permission to use Bluetooth
+            {
                 await Application.Current.MainPage.DisplayAlert("Persmission requise", "L'application a besoin des permissions locales", "OK");
                 return;
+            }
             gattDevices.Clear();                                                                           // Also clear the _gattDevices list
             if (!bluetoothAdapter.IsScanning)                                                              // Make sure that the Bluetooth adapter is scanning for devices
+            {
                 await bluetoothAdapter.StartScanningForDevicesAsync();
+            }
             foreach (var device in bluetoothAdapter.ConnectedDevices)                                      // Make sure BLE devices are added to the _gattDevices list
                 gattDevices.Add(device);
             foreach (var device in bluetoothAdapter.BondedDevices)
                 gattDevices.Add(device);
             foreach (IDevice item in gattDevices)
+            {
                 if (item.Name.Contains("SICPA"))
+                {
                     if (item.State == DeviceState.Connected)                                                // Check first if we are already connected to the BLE Device
+                    {
                         await RecuperationServices(item);
+                    }
                     else
+                    {
                         try
+                        {
                             var connectParameters = new ConnectParameters(false, true);
                             await bluetoothAdapter.ConnectToDeviceAsync(item, connectParameters);          // if we are not connected, then try to connect to the BLE Device selected
                             await RecuperationServices(item);
+                        }
                         catch
+                        {
                             await Application.Current.MainPage.DisplayAlert("Erreur de connexion", "Erreur de connexion au BLE " + item.Name, "OK");
+                        }
+                    }
+                }
+            }
+        }
         private async Task<bool> PermissionsGrantedAsync()      // Function to make sure that all the appropriate approvals are in place
+        {
             var status = await Permissions.CheckStatusAsync<Permissions.LocationWhenInUse>();
             if (status != PermissionStatus.Granted)
+            {
                 status = await Permissions.RequestAsync<Permissions.LocationWhenInUse>();
+            }
             return status == PermissionStatus.Granted;
+        }
         private async Task RecuperationServices(IDevice device)
+        {
             try
+            {
                 var servicesListReadOnly = await device.GetServicesAsync();           // Read in the Services available
                 servicesList.Clear();
                 for (int i = 0; i < servicesListReadOnly.Count; i++)                             // Cycle through the found interfaces
+                {
                     servicesList.Add(servicesListReadOnly[i]);                                 // Write to a list of service interfaces
                     if (servicesListReadOnly[i].Id.ToString().Substring(0, 8) == "6e400001")
+                    {
                         SelectedService = servicesListReadOnly[i];
+                    }
+                }
                 if (SelectedService != null)
+                {
                     var charListReadOnly = await SelectedService.GetCharacteristicsAsync();       // Read in available Characteristics
                     charList.Clear();
                     for (int i = 0; i < charListReadOnly.Count; i++)                               // Cycle through available interfaces
+                    {
                         charList.Add(charListReadOnly[i]);                                        // Write to a list of Chars
                         // IMPORTANT: listview cannot cope with entries that have the exact same name. That is why I added "i" to the beginning of the name. If you add the UUID you can delete "i" again.
                         if (charListReadOnly[i].CanRead || charListReadOnly[i].CanUpdate)
+                        {
                             characRead = charListReadOnly[i];
                             characRead.ValueUpdated += CharacRead_ValueUpdated;
+                        }
                         if (charListReadOnly[i].CanWrite) characWrite = charListReadOnly[i];
+                    }
                     DeviceConnected = device;
+                }
                 else
+                {
                     await Application.Current.MainPage.DisplayAlert("Erreur récupération Characteristics", "Erreur récupération Characteristics", "OK");
+                }
+            }
             catch
+            {
                 await Application.Current.MainPage.DisplayAlert("Erreur d'initialisation", "Erreur d'initialisation aux services", "OK");
+            }
+        }
         private void CharacRead_ValueUpdated(object sender, CharacteristicUpdatedEventArgs args)
+        {
             var receivedBytes = args.Characteristic.Value;                              // read in received bytes
             Console.WriteLine("byte array: " + BitConverter.ToString(receivedBytes));   // write to the console for debugging
             string charStrBytes = "";                                                                           // in the following section the received bytes will be displayed in different ways (you can select the method you need)
             string charStrUTF8 = "";
             if (receivedBytes != null)
+            {
                 charStrBytes = "Bytes : " + BitConverter.ToString(receivedBytes);                                // by directly converting the bytes to strings we see the bytes themselves as they are received
                 charStrUTF8 = Encoding.UTF8.GetString(receivedBytes, 0, receivedBytes.Length);  // This code interprets the bytes received as ASCII characters
+            }
             if (receivedBytes.Length <= 4)
             {                                                                                               // If only 4 or less bytes were received than it could be that an INT was sent. The code here combines the 4 bytes back to an INT
                 int char_val = 0;
                 for (int i = 0; i < receivedBytes.Length; i++)
+                {
                     char_val |= (receivedBytes[i] << i * 8);
+                }
                 charStrBytes += " | int: " + char_val.ToString();
+            }
-f65dee
+            tempoLecture = tempoLecture + charStrUTF8;
             if (args.Characteristic.StringValue.EndsWith("\r\n"))
+            {
                 RetourBLE = tempoLecture;
                 tempoLecture = "";
+            }
-e7d061
+            //_charStr += Environment.NewLine;                                                                // the NewLine command is added to go to the next line
             //MainThread.BeginInvokeOnMainThread(() =>                                      // as this is a callback function, the "MainThread" needs to be invoked to update the GUI
             //{
             //    Output.Text += _charStr;
             //});
+        }
-d21
+        public  async Task LectureTag(IDevice deviceConnected)
+        {
             try
+            {
                 String cmd = "READ";
                 List<byte> local_frame = new List<byte>();
                 CRC crcProcess = new CRC();
                 byte local_crc;
                 local_frame.Add(BytesPrtc.STX); //add STX byte
                 local_frame.Add(BytesPrtc.DST_TX); //add DST byte
                 local_frame.Add(BytesPrtc.SRC_TX); //add SRC byte
                 for (int i = 0; i < cmd.Length; i++)
+                {
                     local_frame.Add((byte)cmd[i]); //add cmd string
+                }
                 crcProcess.putBytes(local_frame.ToArray()); //send that buffer (without "the CRC" and ETX bytes !)
                 local_crc = crcProcess.getCRC(); //calculate CRC with that buffer
                 local_frame.Add(local_crc); //add CRC byte
                 local_frame.Add(BytesPrtc.ETX); //add ETX byte
                 /////////////////////////////////////////////
                 //And now send buffer !
                 await characWrite.WriteAsync(local_frame.ToArray());
                 await characRead.StartUpdatesAsync();
+            }
             catch
+            {
                 await Application.Current.MainPage.DisplayAlert("Erreur de lecture", "Erreur de lecture du Tag", "OK");
+            }
+        }
-e7d061
+            ajournaux
+}