RXTXPortWrapper.java

package kernel.serial_ports;

import gnu.io.PortInUseException;
import gnu.io.RXTXPort;
import gnu.io.UnsupportedCommOperationException;
import org.jetbrains.annotations.Contract;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public final class RXTXPortWrapper implements SerialPort, PortCommunicator,
        PortConfiguration {

    private static Logger log = LoggerFactory.getLogger(RXTXPortWrapper.class);

    private RXTXPort port;

    private final String portName;

    private boolean isPortOpen;

    private PortConfiguration desiredPortConfiguration;

    private Thread shutdownThread;

    RXTXPortWrapper(String portName){
        writeLogEntryForInitialization(portName);
        this.portName = portName;
    }

    @Contract(pure = true)
    @Override public PortCommunicator getCommunicator(){
        return this;
    }

    @Override public InputStream getInputStream() throws IOException {
        assertPortOpen();
        writeLogEntryForInputStreamRequest();
        return this.port.getInputStream();
    }

    @Override public OutputStream getOutputStream() throws IOException {
        assertPortOpen();
        writeLogEntryForOutputStreamRequest();
        return this.port.getOutputStream();
    }

    @Contract(pure = true)
    @Override public PortConfiguration getConfig(){
        return this;
    }

    @Contract(pure = true)
    @Override public int getBaudRate(){
        return this.port.getBaudRate();
    }

    @Contract(pure = true)
    @Override public int getStopBits(){
        return this.port.getStopBits();
    }

    @Contract(pure = true)
    @Override public int getDataBits(){
        return this.port.getDataBits();
    }

    @Contract(pure = true)
    @Override public int getParityBits(){
        return this.port.getParity();
    }

    @Override public void setConfig(PortConfiguration newConfig) {
        this.desiredPortConfiguration = newConfig;
    }

    @Override public void open() throws PortInUseException,
        UnsupportedCommOperationException {
        if (!this.isPortOpen){
            this.port = new RXTXPort(this.portName);
            this.isPortOpen = true;

            shutdownThread = new PortShutdown(this);
            Runtime.getRuntime().addShutdownHook(shutdownThread);

            try {
                setConfigurationParametersForOpenPort();
            } catch (IOException error){
                throw new UnsupportedCommOperationException(
                        "Unable to set port configuration parameters"
                );
            }

            writeLogEntryForPortOpen();
        }
    }

    @Override public boolean isPortOpen(){
        return this.isPortOpen;
    }

    @Override public void close(){
        if (this.isPortOpen){
            this.port.close();
            this.isPortOpen = false;

            Runtime.getRuntime().removeShutdownHook(shutdownThread);

            writeLogEntryForPortClosed();
        }
    }

    private void assertPortOpen() throws IOException {
        if (!this.isPortOpen){
            throw new IOException("Attempted to access a resource that " +
                    "requires the port to be open");
        }
    }

    private void setConfigurationParametersForOpenPort() throws
            UnsupportedCommOperationException, IOException {
        assertPortOpen();
        int baudRate = desiredPortConfiguration.getBaudRate();
        int dataBits = desiredPortConfiguration.getDataBits();
        int stopBits = desiredPortConfiguration.getStopBits();
        int parityBits = desiredPortConfiguration.getParityBits();

        this.port.setSerialPortParams(
                baudRate, dataBits, stopBits, parityBits
        );

        writeLogEntryForParametersSet(baudRate, dataBits, stopBits,
                parityBits);
    }

    private void writeLogEntryForInitialization(String portName){
        log.debug(
                "Port wrapper initialized for RS232 port with name {}",
                portName
        );
    }

    private void writeLogEntryForInputStreamRequest(){
        log.debug(
                "Input stream requested for RS232 port {}", this.portName
        );
    }

    private void writeLogEntryForOutputStreamRequest(){
        log.debug(
                "Output stream requested for RS232 port {}", this.portName
        );
    }

    private void writeLogEntryForParametersSet(
            int baudRate, int dataBits, int stopBits, int parityBits
    ){
        String parameterTemplate = "Parameter {} for port {} was set to {}.";

        log.info(
                parameterTemplate, "Baud Rate", portName, baudRate
        );
        log.info(
                parameterTemplate, "Data Bits", portName, dataBits
        );
        log.info(
                parameterTemplate, "Stop Bits", portName, stopBits
        );
        log.info(
                parameterTemplate, "Stop Bits", portName, parityBits
        );
    }

    private void writeLogEntryForPortOpen(){
        log.info("Port {} was opened.", portName);
    }

    private void writeLogEntryForPortClosed(){
        log.info("Port {} was closed", portName);
    }

    private final class PortShutdown extends Thread {

        private final Logger log = LoggerFactory.getLogger(PortShutdown.class);

        private final SerialPort port;

        public PortShutdown(SerialPort port){
            this.port = port;
        }

        @Override
        public void run() {
            log.info("Port {} caught shutdown signal. Closing", portName);
            this.port.close();
            log.info("Port {} successfully closed", portName);
        }
    }
}