Java Server to Android Client: Cannot receive TCP packets

Question

I'm trying to write a Java server so that an Android client can send a string to it, and the server would reply with its own string. The first part of this works, where the client sends a string to the server, but the server sending a message to the does not work: the packet makes it out of the server, but the Android client does not pick it up. Does anyone have suggestions on how to fix this?

This entire process worked previously on a Python server, but I am changing to Java because of library support (Java has better support for NAT traversal)

Server (Java):

public class TCPServer implements Runnable {
    private Thread t = null;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        String receive;
        String response = "1||2||3||4\n";
        ServerSocket tcpServer = null;
        Socket tcpClient = null;
        try {
            tcpServer = new ServerSocket(4999);
            System.out.println("   TCP open for connections");
            while(true) {
                tcpClient = tcpServer.accept();
                BufferedReader inStream = new BufferedReader(new InputStreamReader(tcpClient.getInputStream()));
                receive = inStream.readLine();
                System.out.println("Server <<< " + receive);

                DataOutputStream outStream = new DataOutputStream(tcpClient.getOutputStream());
                outStream.write(response.getBytes("UTF-8"));
                outStream.flush();
                System.out.println("Server >>> " + response);
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("IOException: " + e.toString());
        } finally {
            if (tcpServer != null) {
                try {
                    tcpServer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    System.out.println("IOException: " + e.toString());
                }
            }
            if (tcpClient != null) {
                try {
                    tcpClient.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    System.out.println("IOException: " + e.toString());
                }
            }
        }
    }

    public void start() {
        // TODO Auto-generated method stub
        if(t == null) {
            t = new Thread(this);
            t.start();
            System.out.println("Start TCP Server");
        }

    }
}

Client (Android):

public class AsyncTCPSend extends AsyncTask<Void, Void, Void> {
            String address = "";
            String message = "";
            String response = "";
            AsyncTCPSend(String addr, String mes) {
                address = addr;
                message = mes + "\n";
            }

            @Override
            protected Void doInBackground(Void... params) {
                Socket socket = null;
                try {
                    socket = new Socket(address, 4999);
                    socket.getOutputStream().write(message.getBytes());

                    ByteArrayOutputStream writeBuffer = new ByteArrayOutputStream(1024);
                    byte[] buffer = new byte[1024];

                    int bytesRead;
                    InputStream writeIn = socket.getInputStream();

                    while((bytesRead = writeIn.read(buffer)) != -1) {
                        writeBuffer.write(buffer,0,bytesRead);
                        response += writeBuffer.toString("UTF-8");
                    }
                } catch (UnknownHostException e){
                    e.printStackTrace();
                    response = "Unknown HostException: " + e.toString();
                    System.out.println(response);
                } catch (IOException e) {
                    response = "IOException: " + e.toString();
                    System.out.println(response);
                } finally {
                    if (socket != null) {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                return null;
            }

            @Override
            protected void onPostExecute(Void result) {
                recieve.setText(response);
                super.onPostExecute(result);
            }
        }

Answer 1

I don't know why you would call an InputStream 'writeIn', but the problem is that the client is reading the socket until end of stream, and the server is never closing the accepted socket, so end of stream never occurs.