Send object over udp in Java

Question

I'm trying to send and object over udp by first serializing it and then deserializing it on the other end. I thought this would be trivial since I have sent other data over udp before and serialized stuff to the files etc.

I have debugged thing some time now and I keep getting EOFException on the receiving end. Packets arrive properly but somehow deserialization fails. I'm not sure if the mistake is in sender or receiver. I suppose the problem might be about the receiver not knowing the size of the packet.

Here is my sender class:

    package com.machinedata.sensordata;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

import android.content.Context;
import android.util.Log;

import com.machinedata.io.DataSerializer;
import com.machinedata.io.ManagerUdpPacket;

/**
 * This class sends udp-packets. It is used to send driver's information to the manager tablet.
 * @author tuomas
 *
 */
public class UdpSender 
{
     private final int MANAGER_PORT = 1234;
     private String ip = "192.168.11.50";   //tablet's IP
     private DatagramSocket sock = null;
     private InetAddress host;
     private String mType;
     private DataSerializer dataser;

    public UdpSender(Context context) 
    {
        try 
        {
            sock = new DatagramSocket();       
            host = InetAddress.getByName(ip);   //tabletin ip
        }
        catch(Exception e)
        {
            System.err.println("Exception alustettaessa senderia" + e);
        }

        dataser = new DataSerializer(context);
    }

    /**
     * With this function we can send packets about our machine to the manager to
     * see in the fleet-view.
     */
    public void sendToManager(ManagerUdpPacket managerUdp)
    {

        //serialize
        Log.v("sendudp", "Send a packet: " + managerUdp.getDriver());

        //serialize
        byte[] data = dataser.serializeManagerPacket(managerUdp);


        //send
        try
        {
                DatagramPacket  dp = new DatagramPacket(data , data.length , host , MANAGER_PORT);
                sock.send(dp);     
        }

        catch(IOException e)
        {
            System.err.println("IOException senderissa " + e);
        }


    }

    public void close()
    {
        sock.close();
    }
}

Here is the serialization function:

/**
 * Serializes packet to be sent over udp to the manager tablet.
 */
public byte[] serializeManagerPacket(ManagerUdpPacket mp)
{
    try
    {
      ByteArrayOutputStream baos = new ByteArrayOutputStream(2048);
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(mp);
      oos.close();
      // get the byte array of the object
      byte[] obj= baos.toByteArray();
      baos.close();
      return obj;
    }
    catch(Exception e) {
        e.printStackTrace();
    }

    return null;

}

Packet receiver class

public class UdpReceiver {

private DatagramSocket clientSocket;
private byte[] receiveData;
private final int timeout = 1;

/**
 * Create a receiver.
 * @param port Port to receive from.
 * @param signCount Number of signals in a packet
 */
public UdpReceiver(int port)
{

    //receiveData = serializeManagerPacket(new ManagerUdpPacket("asd", new MachineData(1, 2, "asd", "modelName"), 1,2,3,4,5.0,null));

    try{
        clientSocket=new DatagramSocket(port);
        clientSocket.setReceiveBufferSize(2048);
        clientSocket.setSoTimeout(timeout);
    }catch(SocketException e){
        Log.e("ERR", "SocketException in UdpReceiver()");
    }
}

public void close()
{
    clientSocket.close();
}

/**
 * Receive a data packet and split it into array.
 * @param data Array to put data in, must be correct size
 * @return True on successful read, false otherwise
 */
public ManagerUdpPacket receive()
{

    //receive a packet
    DatagramPacket recvPacket = new DatagramPacket(receiveData, receiveData.length);
    try{
        clientSocket.receive(recvPacket);
    }catch(IOException e){
        Log.e("ERR", "IOException in UdpReceiver.receive");
        return null;
    }

    ManagerUdpPacket obj = deserializeManagerPacket(receiveData);

    if (obj != null)
        Log.v("udpPacket", "UDP saatu: " + obj.getDriver());
    return obj;
}


/**
 * Deserialize the udp-packet back to readable data. 
 * @param data
 * @return
 */
public ManagerUdpPacket deserializeManagerPacket(byte[] data)
{
    try
    {
        ObjectInputStream iStream = new ObjectInputStream(new ByteArrayInputStream(data));
        ManagerUdpPacket obj = (ManagerUdpPacket) iStream.readObject();
        iStream.close();
            return obj;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

        return null;
    }
}

Thread which listens packets in receiving end:

dataStreamTask = new TimerTask()
    {
        public void run() 
        {
            if (currentlyStreaming) 
            {

                ManagerUdpPacket mp = udpReceiver.receive();

                if(mp != null)
                {
                    Log.v("log", "Paketti saatu! " + mp.getDriver());
                }


                //stop thread until next query
                try {
                    synchronized(this){
                        this.wait(queryInterval);
                    }
                } catch (InterruptedException e) {
                    Log.e("ERR", "InterruptedException in TimerTask.run");
                }
            }

        }

And finally the class I'm sending over the UDP:

    public class ManagerUdpPacket implements Serializable
{
    private static final long serialVersionUID = 9169314425496496555L;

    private Location gpsLocation;
    private double totalFuelConsumption;
    private long operationTime;

    //workload distribution
    private long idleTime = 0;
    private long normalTime = 0;
    private long fullTime = 0;

private int currentTaskId;
private String driverName;
String machineModelName = "";
String machineName = "";
int machineIconId = -1;
int machinePort = -1;

public ManagerUdpPacket(String driver, MachineData machine, int currentTaskId, long idleTime, long fullTime, long operationTime, double fuelConsumption, Location location)
{
    driverName = driver;
    this.currentTaskId = currentTaskId;
    this.idleTime = idleTime;
    this.fullTime = fullTime;
    this.operationTime = operationTime;
    this.totalFuelConsumption = fuelConsumption;
    this.gpsLocation = location;
    machineModelName = machine.getModelName();
    machineName = machine.getName();
    machineIconId = machine.getIconId();
    machinePort = machine.getPort();
}

public String getDriver()
{
    return driverName;
}
public int getCurrentTaskId()
{
    return currentTaskId;
}
public long getIdleTime()
{
    return idleTime;
}
public long getFullTime()
{
    return fullTime;
}
public long getOperationTime()
{
    return operationTime;
}
public double getTotalFuelConsumption()
{
    return totalFuelConsumption;
}
public double getLocation()
{
    return gpsLocation.getLatitude();
}
public String getMachineModelName()
{
    return machineModelName;
}
public String getMachineName()
{
    return machineName;
}
public int getMachineIconId()
{
    return machineIconId;
}
    public int getMachinePort()
    {
        return machinePort;
    }


}

I tried to get the packet size from the size of the serialized packet or inserting arbitrary 2048 based on some examples on internet. Couldn't get it work though.

Answer 1

As far as i know the receive function returns the length of the bytes it received. But your buffer will be full:

Example:

int buffersize = 1024;

You send 8bytes over udp.

So your byte[] will be full with your 8 bytes but the rest of the 1024 will be 0.

save the size you get by the .receive() call and just save all values of your buffer to another byte[] and you should get your object.

For your example:

public ManagerUdpPacket receive()
{
int receivedBytes = 0;

//receive a packet
DatagramPacket recvPacket = new DatagramPacket(receiveData, receiveData.length);
try{
    receivedBytes = clientSocket.receive(recvPacket);
}catch(IOException e){
    Log.e("ERR", "IOException in UdpReceiver.receive");
    return null;
}
byte[] myObject = new byte[receivedBytes];

for(int i = 0; i < receivedBytes; i++)
{
     myObject[i] = receiveData[i];
}

ManagerUdpPacket obj = deserializeManagerPacket(myObject);

if (obj != null)
    Log.v("udpPacket", "UDP saatu: " + obj.getDriver());
return obj;
}

Answer 2

When receiving data on UDP, always use java.net.DatagramSocket.getReceiveBufferSize();. This is the actual size of the platform or SP_RCVBUF for the socket. Since UDP is a datagram based protocol unlike TCP, which is streaming protocol, receiving buffers become critical for data sanity. Usually, receiving and sending buffers are equal in size, but you are not bothered while sending when using DatagramSocket.send(DatagramPacket), alternately, you can also use DatagramSocket.setSendBufferSize(DatagramSocket.getSendBufferSize()) for using the SO_SNDBUF option for this socket. Keep in mind, in UDP, if you use a SO_SNDBUF size greater than platform's, the packet can be discarded.