bluetooth: update the write process to slice the data based on the MTU size

It has been observed that, if a data packet bigger than the negotiated MTU size
is sent using the Tx characteristic, the connection with the BLE device is lost
after a small timeout.

This commit fixes this scenario as follows:
- The data packet to send is sliced using the MTU size minus 3 bytes as
  established in the Bluetooth core specification.
- If any of the slices is not written correctly, the whole write operation is
  considered as failed.

While on it, make the write_data method async by awaiting the inner write task.
This avoids spurious micro-hangs while sending data to the BLE device.

Signed-off-by: Diego Escalona <[email protected]>
Signed-off-by: David Escalona <[email protected]>

Author: daescalona

XBeeLibrary.Xamarin/Connection/Bluetooth/BluetoothInterface.cs

@@ -19,6 +19,7 @@
 using Plugin.BLE.Abstractions.Contracts;
 using Plugin.BLE.Abstractions.EventArgs;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -44,7 +45,7 @@ public class BluetoothInterface : IConnectionInterface
 
 		private static readonly int LENGTH_COUNTER = 16;
 
-		private static readonly int REQUESTED_MTU = 255;
+		private static readonly int REQUESTED_MTU = 512; // Maximum ATT layer MTU size.
 
 		private static readonly string ERROR_INVALID_MAC_GUID = "Invalid MAC address or GUID, it has to follow the format 00112233AABB or " +
 			"00:11:22:33:AA:BB for the MAC address or 01234567-0123-0123-0123-0123456789AB for the GUID";
@@ -413,7 +414,7 @@ public void WriteData(byte[] data)
 		/// <param name="length">The number of bytes to write.</param>
 		/// <exception cref="XBeeException">If there is any error writing data.</exception>
 		/// <seealso cref="WriteData(byte[])"/>
-		public void WriteData(byte[] data, int offset, int length)
+		public async void WriteData(byte[] data, int offset, int length)
 		{
 			// Wait for other device operations.
 			deviceSemaphore.Wait(WRITE_TIMEOUT);
@@ -423,24 +424,27 @@ public void WriteData(byte[] data, int offset, int length)
 				throw new XBeeException(ERROR_CONNECTION_CLOSED);
 			}
 
-			// Prepare data to write.
-			Debug.WriteLine("----- WriteData " + HexUtils.ByteArrayToHexString(data));
-			byte[] buffer = new byte[length];
-			Array.Copy(data, offset, buffer, 0, length);
-			byte[] dataToWrite = encrypt ? encryptor.TransformFinalBlock(buffer, 0, buffer.Length) : buffer;
-
 			// Abort the write operation if the write timeout expires.
 			CancellationTokenSource cancelToken = new CancellationTokenSource(WRITE_TIMEOUT);
 			bool success = false;
-			Task writeTask = Task.Run(async () =>
+			await Task.Run(async () =>
 			{
 				// According to BLE.Plugin API documentation, every write operation
 				// must be executed in the main thread.
 				await MainThread.InvokeOnMainThreadAsync(async () => 
 				{
 					try
 					{
-						success = await txCharacteristic.WriteAsync(dataToWrite, cancellationToken: cancelToken.Token);
+						// Split the data in slices with a max length of the current MTU minus 3.
+						foreach (byte[] slice in SliceData(data))
+						{
+							// Write the slices in the TX characteristic. Stop if one of them fails.
+							Debug.WriteLine("----- WriteData " + HexUtils.ByteArrayToHexString(slice));
+							byte[] dataToWrite = encrypt ? encryptor.TransformFinalBlock(slice, 0, slice.Length) : slice;
+							success = await txCharacteristic.WriteAsync(dataToWrite, cancellationToken: cancelToken.Token);
+							if (!success)
+								throw new XBeeException(ERROR_WRITE);
+						}
 					}
 					catch (Exception)
 					{
@@ -452,8 +456,7 @@ await MainThread.InvokeOnMainThreadAsync(async () =>
 					}
 				});
 			});
-			// Wait for write task to complete.
-			Task.WaitAll(writeTask);
+
 			// Free semaphore.
 			deviceSemaphore.Release();
 			// Check for error.
@@ -463,6 +466,43 @@ await MainThread.InvokeOnMainThreadAsync(async () =>
 			}
 		}
 
+
+		/// <summary>
+		/// Returns a list with the data slices of the given byte array. The
+		/// maximum length of each slice is the negotiated MTU minus 3 bytes.
+		/// 
+		/// According to the Bluetooth core specification, the attribute protocol
+		/// needs 3 bytes for the opcode (write command) and the attribute handle
+		/// (which attribute to write to). So, the actual data length is always
+		/// ATT_MTU minus 3.
+		/// </summary>
+		/// <param name="data">Data to get the slices from.</param>
+		/// <returns>A list with the data slices.</returns>
+		private List<byte[]> SliceData(byte[] data)
+		{
+			List<byte[]> slices = new List<byte[]>();
+
+			if (data.Length <= (mtu - 3))
+			{
+				slices.Add(data);
+			}
+			else
+			{
+				int i = 0;
+				while (i < data.Length)
+				{
+					int remainingLength = data.Length - i;
+					int bufferLength = remainingLength < (mtu - 3) ? remainingLength : (mtu - 3);
+					byte[] buffer = new byte[bufferLength];
+					Array.Copy(data, i, buffer, 0, bufferLength);
+					slices.Add(buffer);
+					i += bufferLength;
+				}
+			}
+
+			return slices;
+		}
+
 		/// <summary>
 		/// Returns the connection type of this bluetooth XBee interface.
 		/// </summary>