CODEWITHSUNDEEP
javaandroidmultithreadingtcpandroid-asynctask
Arctic Conductor
Arctic Conductor

Reputation: 163

Android - multithread TCP connection

I've been searching for an answer to my problem, but none of the solutions so far have helped me solve it. I'm working on an app that communicates with another device that works as a server. The app sends queries to the server and receives appropriate responses to dynamically create fragments.

In the first implementation the app sent the query and then waited to receive the answer in a single thread. But that solution wasn't satisfactory since the app did not receive any feedback from the server. The server admin said he was receiving the queries, however he hinted that the device was sending the answer back too fast and that the app probably wasn't already listening by the time the answer arrived.

So what I am trying to achieve is create seperate threads: one for listening and one for sending the query. The one that listens would start before we sent anything to the server, to ensure the app does not miss the server response.

Implementing this so far hasn't been succesful. I've tried writing and running seperate Runnable classes and AsyncTasks, but the listener never received an answer and at some points one of the threads didn't even execute. Here is the code for the asynctask listener:

            @Override
        protected String doInBackground(String... params) {

            int bufferLength = 28;
            String masterIP = "192.168.1.100";

            try {
                Log.i("TCPQuery", "Listening for ReActor answers ...");
                Socket tcpSocket = new Socket();
                SocketAddress socketAddress = new InetSocketAddress(masterIP, 50001);
                try {               
                    tcpSocket.connect(socketAddress);
                    Log.i("TCPQuery", "Is socket connected: " + tcpSocket.isConnected());

                } catch (IOException e) {
                    e.printStackTrace();
                }

                while(true){

                    Log.i("TCPQuery", "Listening ...");
                    try{
                        Log.i("TCPQuery", "Waiting for ReActor response ...");
                        byte[] buffer = new byte[bufferLength];
                        tcpSocket.getInputStream().read(buffer);
                        Log.i("TCPQuery", "Received message " + Arrays.toString(buffer) + " from ReActor.");
                    }catch(Exception e){
                        e.printStackTrace();
                        Log.e("TCPQuery", "An error occured receiving the message.");
                    }
                }

            } catch (Exception e) {
                Log.e("TCP", "Error", e);
            }

            return "";
        }

And this is how the tasks are called:

        if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.HONEYCOMB) {
          listener.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
          sender.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
        }
        else {
          listener.execute();
          sender.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }

How exactly would you approach this problem? If this code is not sufficient I would be glad to post more.

Upvotes: 1

Views: 769

Answers (2)

Suvam Roy
Suvam Roy

Reputation: 1280

Look this is tcp connection. So you don't need to bother about data lose. This is port to port connection and it never sends end of stream (-1). Perhaps you have to care about read functionality. Because you can not conform all steams are received or not. Tcp read method is a blocking call. If your read buffer size is smaller than available stream size then it block until it can read fully. And you are using android device, perhaps available stream can vary depending upon your device network. So you have 2 options, 1) your buffer size should be dynamic. At first check your available input stream size by using is.available() and create your buf size by this size. If available size is zero then sleep for a certain time to check it is lost its stream availability or not. 2) set your input stream timeout. It really works, because it reads its available stream and wait for the timeout delay, if any stream is not available within the timeout period then it throws timeout exception. Try to change your code.

Upvotes: 0

m0skit0
m0skit0

Reputation: 25873

This is because Android's AsyncTask is actually only one thread, no matter how many you create, so if you really want 2 threads running at the same time, I suggest you use standard Java concurrent package tools, not AsyncTask. As explained in the documentation:

AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework. AsyncTasks should ideally be used for short operations (a few seconds at the most.) If you need to keep threads running for long periods of time, it is highly recommended you use the various APIs provided by the java.util.concurrent pacakge such as Executor, ThreadPoolExecutor and FutureTask.

Upvotes: 1

Related Questions