Android FileChannel读取和写入在不同的AsyncTask中失败

Question

I have a Service class that communicates with my another process, let's say process_A, by local socket.

My Service class is as follows:

public class MyService extends Service {
    private LocalSocket localSock;
    private LocalSocketAddress localSockAddr;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (intent.getAction().equals(START_SERVICE_ACTION)) {
            localSock = new LocalSocket();
            localSockAddr = new LocalSocketAddress(LOCAL_SOCK_ADDR, LocalSocketAddress.Namespace.ABSTRACT);
            try {
                localSock.connect(localSockAddr);
            } catch (IOException e) {
                // Ignore
            }

            if (localSock.isConnected()) {
                new LocalSockInitTask().execute(localSock);
            }
        } else if (intent.getAction().equals(STOP_SERVICE_ACTION)) {
            new LocalSockTermTask().execute(localSock);
        }
    }
}

The behaviour should be as follows:

1. When my service is being started by user, the service uses LocalSocket.connect() to connect with process_A. Once connected successfully, the service executes an AsyncTask to send an INIT message to process_A and wait for an INIT message from process_A.
2. When my service is being stopped by user, the service executes another AsyncTask to send a TERM message to process_A and wait for a TERM message from process_A.

LocalSockInitTask.java:

public class LocalSockInitTask extends AsyncTask<LocalSocket, Void, Boolean> {
    @Override
    protected Boolean doInBackground(LocalSocket... params) {
        LocalSocket localSock = params[0];
        FileChannel inChannel;
        FileChannel outChannel;
        ByteBuffer sendBuf, recvBuf;
        byte[] bytes;
        String result, recvMsg;
        int attempt;

        try {
            inChannel = new FileInputStream(localSock.getFileDescriptor()).getChannel();
            outChannel = new FileOutputStream(localSock.getFileDescriptor()).getChannel();

            // Send INIT Message
            sendBuf = ByteBuffer.wrap(MSG_INIT.getBytes());
            outChannel.write(sendBuf);

            // Wait for INIT Message
            recvBuf = ByteBuffer.allocate(BUFFER_SIZE);
            attempt = 0;
            while (inChannel.read(recvBuf) < 0) {
                attempt++;
                if(attempt == 5)
                    return false;

                Thread.sleep(1000);
            }

            recvBuf.flip();
            bytes = new byte[recvBuf.remaining()];
            recvBuf.get(bytes);

            result = new String(bytes);
            if(!result.equals(MSG_INIT))
                return false;

            inChannel.close();
            outChannel.close();

            return true;
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }
}

LocalSockTermTask.java is nearly doing the same as LocalSockInitTask.java, the major difference is just the message being send and receive is "MSG_TERM".

The Init task is doing perfectly, both write and read are successful. However, when executing the second AsyncTask (which is LocalSockTermTask), seems both write and read are unsuccessful. I've done some testing on this line:

inChannel.read(recvBuf);

In the first AsyncTask execution (LocalSockInitTask), if nothing can be read, this method will immediately return -1 and that's why I set a while loop and count the attempt.

In the second AsyncTask execution (LocalSockTermTask), if nothing can be read, this method will be blocked, and this makes my while loop and attempt count become useless. This cause the AsyncTask never complete. Also, My process_A is waiting for "MSG_TERM" to terminate, and it remains running, that's why I think outChannel.write(sendBuf) also failed in Term task.

Currently I am passing the LocalSocket object to both AsyncTask and create a pair of in/out FileChannel in the AsyncTask. I've also tried to create a pair of in/out FileChannel in the service and pass the two FileChannel to AsyncTask, but still facing the same problem.

Any help is greatly appreciated!

Answer 1

OK, I just found out that this is my careless mistake. The problem is solved.

1. My another process handles the TERM message incorrectly, so it just simply ignore the TERM message sent by my AsyncTask, and therefore it continues to run and wait for messages.

2. Since it ignores the TERM message, it won't send back a TERM message to my AsyncTask, and this cause the inChannel.read(recvBuf) has nothing to read.

3. The blocking behavior of inChannel.read(recvBuf) is absolutely normal, returning -1 should be the case that I use BufferedReader before I changed to use FileChannel .