Maximum number of packets in BLE write characteristic

Question

I am writing a Xamarin.Android application, but this question is applicable to native Android and BLE in general. I have a write characteristic that I can write to, and it works as long as I don't send more than 600 characters. Anything over 600 characters gets truncated. Looking at my logs, I can see that the text is being split into 20 character packets, and OnCharacteristicWriteRequest is called for each packet, but stops being called after 600 characters. I am testing with 2 Android tablets. My code to write to the characteristic:

public override void OnServicesDiscovered(BluetoothGatt gatt, [GeneratedEnum] GattStatus status)
{
    base.OnServicesDiscovered(gatt, status);

    try
    {
        if (status != GattStatus.Success)
        {
            Log?.Invoke("discover services failed");
            return;
        }

        Log?.Invoke("services discovered");

        if(RequestForAddressExists(gatt.Device.Address))
        {
            lock (_requestsLocker)
            {
                Java.Util.UUID serviceUuid = GetRequestedServiceUuid(gatt.Device.Address);
                Java.Util.UUID characteristicUuid = GetRequestedCharacteristicUuid(gatt.Device.Address);

                BluetoothGattCharacteristic characteristic = gatt.GetService(serviceUuid).GetCharacteristic(characteristicUuid);

                Log?.Invoke("characterisitic found");

                var request = _requests.FirstOrDefault(r => r.DeviceAddress == gatt.Device.Address);

                if (characteristic.Properties.HasFlag(GattProperty.Write))
                {
                    Log?.Invoke("writing characteristic...");

                    string data = ((WriteCharacteristicRequest)request).Data;

                    characteristic.SetValue($"{data}{Constants.WriteCharacteristicEndDelimiter}");
                    characteristic.WriteType = GattWriteType.Default;
                    gatt.WriteCharacteristic(characteristic);
                }
                else
                {
                    Log?.Invoke("GattProperty not supported");
                    _requests.Remove(request);
                }
            }
        }
    }
    catch (Exception e)
    {
        Log?.Invoke(e.Message);
    }
}

public override void OnCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, [GeneratedEnum] GattStatus status)
{
    base.OnCharacteristicWrite(gatt, characteristic, status);

    if (status != GattStatus.Success)
    {
        Log?.Invoke($"OnCharacteristicWrite status not success: {status}");
    }
    else
    {
        Log?.Invoke("OnCharacteristicWrite success");
    }

    gatt.Disconnect();
    gatt.Close();

    lock (_requestsLocker)
    {
        var r = _requests.FirstOrDefault(x => x.DeviceAddress == gatt.Device.Address);

        if (r != null)
        {
            _requests.Remove(r);
        }
    }
}

My code to accept the write request:

public override void OnCharacteristicWriteRequest(BluetoothDevice device, int requestId, BluetoothGattCharacteristic characteristic, bool preparedWrite, bool responseNeeded, int offset, byte[] value)
{
    base.OnCharacteristicWriteRequest(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value);

    Log?.Invoke("OnCharacteristicWriteRequest");

    string data = System.Text.Encoding.UTF8.GetString(value);

    Log?.Invoke(data);

    string characteristicId = new Guid(characteristic.Uuid.ToString()).ToString().ToUpperInvariant();
    var record = _writeCharacteristicsReceived.FirstOrDefault(c => c.DeviceAddress == device.Address && c.CharacteristicId.ToUpperInvariant() == characteristicId);

    if(record != null)
    {
        record.Data += data;
    }
    else
    {
        record = new CharacteristicWriteReceived()
        {
            CharacteristicId = characteristicId,
            DeviceAddress = device.Address,
            Data = data
        };

        _writeCharacteristicsReceived.Add(record);
    }

    if (record.Data.EndsWith(Constants.WriteCharacteristicEndDelimiter) == true)
    {
        Log?.Invoke("end found");

        _writeCharacteristicsReceived.Remove(record);
        record.Data = record.Data.Substring(0, record.Data.Length - Constants.WriteCharacteristicEndDelimiter.Length); // remove the end delimeter
        Log?.Invoke(record.Data);

        OnCharacteristicWriteReceived?.Invoke(record);
    }

    if (responseNeeded)
    {
        BluetoothGattServer.SendResponse(device, requestId, GattStatus.Success, 0, value);
    }
}

public override void OnExecuteWrite(BluetoothDevice device, int requestId, bool execute)
{
    // need to override OnExecuteWrite and call SendResponse here as well,
    // since the execute packet corresponds to the last ATT packet that the client sends as a "finish" marker,
    // and the client expects a response to know that the server accepted the writes

    base.OnExecuteWrite(device, requestId, execute);

    BluetoothGattServer.SendResponse(device, requestId, GattStatus.Success, 0, new byte[0]);
}

The funny thing is, even when the text is truncated, I still get status == GattStatus.Success in my OnCharacteristicWrite. Why is it being truncated? Is there a maximum number of packets that can be sent?

Both devices are continuously advertising and scanning on BLE while writing to this characteristic...could that cause a problem?

Answer 1

A characteristic value can only be 512 bytes long per specification. Writing a longer value is not allowed, even if apparently some stacks don't enforce it. When you write a value longer than what fits in the MTU (default 23 bytes minus 3 for header), the sender Bluetooth stack splits it up in multiple chunks (Prepared Write) and then sends an Execute request to commit. For each chunk you have the offset parameter so you know at which offset to write the current chunk.