Android TCP Socket InputStrem Intermittent Read or too Slow

Question

I need to implement a TCP comunication between an IoT device(custom) and an Android App. For the Wifi device we have a Server Socket, while in Android i have an AsyncTask as a Client Socket. Both the device and the smarthone are connected to the same network.

Here is the Android Client Socket code for the initialization/socket-read and socket-write:

Variables:

static public Socket nsocket; //Network Socket
static public DataInputStream nis; //Network Input Stream
static private OutputStream nos; //Network Output Stream

AsyncTask method doInBackgroud:

@Override
protected Boolean doInBackground(Void... params) { //This runs on a different thread
    boolean result = false;

    try {
        //Init/Create Socket
        SocketInit(IP, PORT);

        // Socket Manager
        SocketUpdate();
    } catch (IOException e) {
        e.printStackTrace();
        Log.i("AsyncTask", "doInBackground: IOException");
        clearCmdInStack();
        MainActivity.SocketDisconnectAndNetworkTaskRestart();
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
        Log.i("AsyncTask", "doInBackground: Exception");
        result = true;
    } finally {
        try {
            SocketDisconnect();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        Log.i("AsyncTask", "doInBackground: Finished");
    }
    return result;
}

Socket Initializzation:

public void SocketInit(String ip, int port) throws IOException {
    InetAddress addr = InetAddress.getByName(ip);
    SocketAddress sockaddr = new InetSocketAddress(addr, port);
    nsocket = new Socket();
    nsocket.setReuseAddress(false);      
    nsocket.setTcpNoDelay(true);           
    nsocket.setKeepAlive(true);          
    nsocket.setSoTimeout(0);
    nsocket.connect(sockaddr, 0);     
    StartInputStream();
    StartOutputStream();
}

Read from Socket:

private void SocketUpdate() throws IOException, ClassNotFoundException {
    int read = 0;
    // If connected Start read
    if (socketSingleton.isSocketConnected()) {
        // Print "Connected!" to UI
        setPublishType(Publish.CONNECTED);
        publishProgress();

        if(mConnectingProgressDialog != null)
            mConnectingProgressDialog.dismiss();  //End Connecting Progress Dialog Bar

        //Set Communications Up
        setCommunicationsUp(true);

        Log.i("AsyncTask", "doInBackground: Socket created, streams assigned");
        Log.i("AsyncTask", "doInBackground: Waiting for inital data...");
        byte[] buffer = new byte[3];

        do{
            nis.readFully(buffer, 0, 3);
            setPublishType(Publish.READ);

            publishProgress(buffer);
        }while(!isCancelled());
        SocketDisconnect();
    }
}

Streams init:

public void StartInputStream() throws IOException{
    nis = new DataInputStream(nsocket.getInputStream());
}

public void StartOutputStream() throws IOException{
    nos = nsocket.getOutputStream();
}

Read and Write methods:

public int Read(byte[] b, int off, int len) throws  IOException{
    return nis.read(b, off, len); //This is blocking
}

public void Write(byte b[]) throws IOException {
    nos.write(b);
    nos.flush();
}

public boolean sendDataToNetwork(final String cmd)
{
    if (isSocketConnected())
    {
        Log.i("AsyncTask", "SendDataToNetwork: Writing message to socket");
        new Thread(new Runnable()
        {
            public void run()
            {
                try
                {
                    Write(cmd.getBytes());
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                    Log.i("AsyncTask", "SendDataToNetwork: Message send failed. Caught an exception");
                }
            }
        }).start();

        return true;
    }

    Log.i("AsyncTask", "SendDataToNetwork: Cannot send message. Socket is closed");
    return false;
}

---

The application is very simple, the android app sends a command(via sendDataToNetwork method) to the IoT device and the latter sends back an "ACK" Command string.

---

The problem

The problem is that while the IoT device always receives the command, the smartphone rarely gets the ACK back. Sometimes i get something like "ACKACKACKACK". By debugging the IoT device i'm sure that it successfully sends back the ACK, so the problem lies in the InputStream read() method which doesn't retrieve the string right away.

Is there a way to empty the InputStream buffer right away, so that i get an "ACK" string back from the IoT device every time i send a command?

---

Update

I've updated the socket config so that there are no more buffer limitations and i've replaced read() method with readFully. It greatly improved, but still make some mistakes. For istance one out of 2-3 times no ack is received and i get 2 ack the next turn. Is this perhaps the computational limit of the IoT device? Or is there still margin for a better approach?

Answer 1

the problem lies in the InputStream read() method which doesn't empty the buffer right away.

I don't know what 'empty the buffer' means here, but InputStream.read() is specified to return as soon as even one byte has been transferred.

Is there a way to empty the InputStream buffer right away, so that i get an "ACK" string back from the IoT device every time i send a command?

The actual problem is that you could be reading more than one ACK at a time. And there are others.

1. If you're trying to read exactly three bytes, you should be using DataInputStream.readFully() with a byte array of three bytes.
2. This will also get rid of the need for the following array copy.
3. You should not mess with the socket buffer sizes except to increase them. 20 and 700 are both ridiculously small values, and will not be the actual values used, as the platform can adjust the value supplied. Your claim that this improved things isn't credible.
4. You should not spin-loop while available() is zero. This is literally a waste of time. Your comment says you are blocked in the following read call. You aren't, although you should be. You are spinning here. Remove this.