LspClient.java

Vá para a documentação deste arquivo.

package lsp;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.concurrent.TimeoutException;

public class LspClient {
    private final LspSocket lspSocket;
    private final LspConnection conn;
    private final LspParams params;

    private volatile boolean active = true;
    private volatile boolean markClosed = false;

    public LspClient(String host, int port, LspParams params) throws IOException, TimeoutException {
        SocketAddress sockAddr = new InetSocketAddress(host, port);
        params = (params == null) ? LspParams.defaultParams() : params;


        lspSocket = new LspSocketImpl(0);
        try {
            conn = lspSocket.connect(sockAddr, params, new ClientTriggers());
            this.params = params;
        } catch (TimeoutException e) {
            lspSocket.close();
            throw e;
        }
    }

    public short getConnId() {
        return conn.getId();
    }

    public byte[] read() {
        try {
            checkActive();
            return lspSocket.receive().getPayload();
        } catch (ClosedConnectionException | NullPointerException e) {
            return null;
        }
    }

    public void write(byte[] payload) {
        checkActive();

        Pack p = new Pack(conn.getId(), payload);
        lspSocket.send(p);
        conn.incSendMissing();
    }

    public void close() {
        checkActive();

        // Marca a conexão como fechada e se não há mensagens para serem
        // enviadas, encerra realmente a conexão.
        markClosed = true;
        conn.close(false);
        if (conn.getSendMissing() == 0) {
            realClose();
            return;
        }

        while (!conn.isInterrupted()) {
            try {
                Thread.sleep(params.getEpoch());
            } catch (InterruptedException e) {
                realClose();
                return;
            }
        }
    }

    private void realClose() {
        this.active = false;
        this.conn.close();
        this.lspSocket.close();
    }

    private void checkActive() {
        if (!active || markClosed)
            throw new ClosedConnectionException();
    }

    private final class LspSocketImpl extends LspSocket {
        LspSocketImpl(int port) throws IOException {
            super(port);
        }

        @Override
        boolean isActive() {
            return active;
        }

        @Override
        LspConnection usedConnection(short connId) {
            if (conn != null && conn.getId() == connId) {
                return conn;
            } else {
                return null;
            }
        }
    }

    private final class ClientTriggers implements ConnectionTriggers {
        @Override
        public void doEpochActions() {
            Helpers.resendData(lspSocket, conn);
            Helpers.resendAck(lspSocket, conn);
        }

        @Override
        public void doCloseConnection() {
            realClose();
        }
    }
}