How to receive single bytes from usb serial device in Android

I am writing an android app in c# (using Avalonia) to communicate with my embedded usb device. The device has an atxmega microcontroller and utilises the atmel provided cdc usb driver. I have a desktop version of the app using System.IO.Ports.SerialPort. I use SerialPort.Write() to write data and SerialPort.ReadByte() in a loop to read data - using SerialPort.Read() and trying to read multiple bytes very often fails, while the looped byte by byte reading basically never does. It works on both Windows and Mac pcs.

The communication is very straightforward - the host sends commands and expects a known length of data to come in from the device.

On the android app I am using the android.hardware.usb class and adapted the code from the multiple serial port wrappers for cdc devices. Here is my connect function:

  public static bool ConnectToDevice()
    {
        if (Connected) return true;

        UsbDevice myDevice;

        if ((myDevice = GetConnectedDevice()) == null) return false;

        if (!HasPermission(myDevice)) return false;

        var transferInterface = myDevice.GetInterface(1);
        var controlInterface = myDevice.GetInterface(0);
        writeEndpoint = transferInterface.GetEndpoint(1);
        readEndpoint = transferInterface.GetEndpoint(0);

        deviceConnection = manager.OpenDevice(myDevice);

        if (deviceConnection != null)
        {
            deviceConnection.ClaimInterface(transferInterface, true);
            deviceConnection.ClaimInterface(controlInterface, true);

            SendAcmControlMessage(0x20, 0, parameterMessage); 
            SendAcmControlMessage(0x22, 0x03, null); //Dtr Rts true

            Connected = true;
            OnConnect?.Invoke();

            return true;
        }

        return false;
    }

The two control transfers are what I borrowed from the serial port wrappers and I use them to:

1. Set the default parameters - 115200 baudrate, 1 stop bit, parity none, 8 data bits which is the same as in my embedded usb config. This doesn't seem necessary but I do it anyway. The response from the control transfer is 7, so I assume it works properly.
2. Set Dtr and Rts to true. This doesn't seem to be necessary either - the desktop code works with both set to false as well as to true. The control transfer response is 0 so I assume it also works properly.

I checked all endpoints and parameters after connection and they all seem to be correct - both read and write Endpoints are bulk endpoints with correct data direction.

Writing to my device is not a problem. I can use either the bulkTransfer method as well as UsbRequest and they both work perfectly.

Unfortunately everything falls apart when trying to read data. The initial exchange with the device is as follows:

1. Host sends a command and expects 4 bytes of data.
2. Host sends another command and expects 160 bytes of data.

The bulk transfer method looks like this:

public static byte[] ReadArrayInBulk(int length)
    {
        byte[] result = new byte[length];

        int transferred = deviceConnection.BulkTransfer(readEndpoint, result, length, 500);

        if (transferred != length)
        {
            transferred = deviceConnection.BulkTransfer(readEndpoint, result, length, 500);
        }

        return result;
    }

The first transfer almost always (99.9%) returns 0 and then the second returns the proper data, up to a point. For the first exchange it does receive the 4 bytes correctly. However, for the second exchange, when it expects 160 bytes the second transfer returns 80, 77, 22 and other random lengths of data. I tried making a loop and performing bulk transfers until the number of bytes transferred is equal to the expected amount but unfortunately after receiving the random length of data for the first time the bulk transfer starts always returning 0.

So I tried the UsbRequest way to get the data:

 public static byte[] GetArrayRequest(int length)
    {
        byte[] result = new byte[length];

        UsbRequest req = new UsbRequest();
        req.Initialize(deviceConnection, readEndpoint);

        ByteBuffer buff = ByteBuffer.Wrap(result);

       req.Queue(buff, length);

        var resulting = deviceConnection.RequestWait();

        if (resulting != null) buff.Get(result);

        req.Close();

        return result;
    }

The WrapBuffer does get filled with the expected amount of data (the position is the same as length), unfortunately the data is all 0. It does work for a couple transfers once in a while, but 99% of the time it just returns zeroes.

So, given that the desktop version also has trouble reading data in bulk using the SerialPort.Read() method but works perfectly when reading them one by one (SerialPort.ReadByte() which underneath uses SerialPort.Read() for a single byte) in a loop I decided to try doing that in my app as well.

Unfortunately, when looping using the UsbRequest method not only does it take ages but it also always returns zeroes. When looping using the BulkTransfer method for a single byte array it returns 0 on the first transfer and -1 on the second, indicating a timeout.

I have spent so much time with this that I am at my wits' end. I checked multiple implementations of usb serial for android projects from mik3y, kai-morich, felHR85 but all they do differently from me are the two control transfers, which I have now added - to no avail.

Can anyone tell me what could cause the bulkTransfer to always return 0 in response to the first transfer (which is supposed to be a success, but what does it actually do with no data read?) and only return some data or timeout (in case of a single byte transfer) on the second one? If it were reliably doing so I would just get used to it, but unfortunately it only seems to work correctly for smaller transfers and only up to a certain point, because while the initial couple/couple dozen bytes are correct, then it stops receiving any more in random intervals. Or why the UsbRequest method does fill the buffers, but with only zeroes 99% of the time?