Question

I am sending data from one device to another (Samsung Tab and Sony Xperia).
All is ok until I reach a length of 994 bytes.
At that point it splits it into 2 messages of 990 and 4 bytes. So, of course, the de-serialization fails.
I’m not sure if the splitting is at the sender end or the receiver end.

Why is that?
Is there a maximum it can send in one go?

If so, how can I piece it together?
If I knew that 990 was a fixed number then I could do it easily by combining them but does it vary from device to device?

I am giving it a buffer of 2000 bytes to receive into so there should be plenty of room.

I am using the code from the Bluetooth example.

======================================================================

As per TJD below:

At the moment I send an object like this:

public class BTMessage implements Serializable {

/**
 * 
 */
private static final long serialVersionUID = -2037775782014806765L;
public int what;
public Object objectToSend;
public int playerId;
public int currentPlayerId;
public BTMessage(int what, int playerId, int currentPlayerId, Object objectToSend){
    this.what = what;
    this.playerId = playerId;
    this.currentPlayerId = playerId;
    this.objectToSend = objectToSend;
}

objectToSend is a serialiazble object.

I then serialize it to a byte array and send it.

BTMessage btMessage = new BTMessage(what,playerId,currentPlayerId,objectToWrite);
write(toByteArray(btMessage));

At the other end I reverse the procedure.

Problem is that adding the length would not always help since, when deserializing the received message it will also want to deserialize the “objectToSend”. Since the message is incomplete I still end up with the same problem.

The only thing I can think of is to change it to:

public class BTMessage implements Serializable {
/**
 * 
 */
private static final long serialVersionUID = -2037775782014806765L;
    public int len;
public int what;
public byte[] objectToSend;
public int playerId;
public int currentPlayerId;
public BTMessage(int len, int what, int playerId, int currentPlayerId, byte[] objectToSend){
            this.len = len;
    this.what = what;
    this.playerId = playerId;
    this.currentPlayerId = playerId;
    this.objectToSend = objectToSend;
}

Then I would do the serialization in 2 steps. First I would serialize the object I want to send into the byte array. Then I would instantiate the “BTMessage” passing the byte array created from the serialization as “objectToSend” and serialize then that.
The above would now be:

byte[] message = toByteArray(objectToWrite);
BTMessage btMessage = new BTMessage(message.length,what,playerId,currentPlayerId,message);
write(toByteArray(btMessage));

At the other end, I would deserialize the received message. I would then check the length and perform another read until I have the full length.
Only then would I deserialize the full object sent (objectToSend).

Is this the way to go?

Answer 1

Are you using RFCOMM to send the data? If so, then you can’t rely on any assumptions about packet size. The RFCOMM abstraction is similar to a serial port, where you are just sending streams of bytes. There is no concept of packets in the RFCOMM data.

You may find that naturally small packets usually get lumped together, but the segmentation size over the air will always vary depending on internal parameters specific to each bluetooth chip. There is no setting for you to control that would reliably preserve your expected packet size.

You should do what you would do for serial port data, overlay your own packet headers in the data so the other side can reassemble. This could be as simple as sending an extra two byte length value before the rest of each data packet. Then the receiver gets a data stream that is self-describing.