Retirada de um dispositivo serial ocasiona Erro fatal no JDK. Falta algum Exception?

Ola amigos,

Estou desenvolvendo uma aplicação que possui comunicação serial com a API RXTXcomm e estou enfrentando um problema com o JDK, ele trava e apresenta erro "Aquelas telinhas para procurar uma Solução Online :shock: ".
Esse problema é ocasionado quando por algum motivo é desconectado o dispositivo serial sem fechar a conexão, ou seja se tiver algum mal contato no dispositivo vai ser um problemão.
acredito que seja por falta de algum Exception especifico, alguém sabe identificar essa falta pelo meu código abaixo?



package Modem;

import gnu.io.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.TooManyListenersException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SerialConnection implements SerialPortEventListener,
					 CommPortOwnershipListener {

 
    private SerialParameters parameters;
    private OutputStream os;
    private InputStream is;
    private KeyHandler keyHandler;

    private CommPortIdentifier portId;
    private SerialPort sPort;

    private boolean open;

    private String receptionString="";

    public String getIncommingString(){
      byte[] bVal= receptionString.getBytes();
      
      return new String (bVal);
  }

    public SerialConnection(SerialParameters parameters) {
        this.parameters = parameters;
	open = false;
   }

   public void openConnection() throws Exception {

	try {

	    portId = CommPortIdentifier.getPortIdentifier(parameters.getPortName());
	} catch (NoSuchPortException e) {
	}catch(Exception e)
        {
        }
       
	try {
	    sPort = (SerialPort)portId.open("Connector1", 200000000);
	} catch (PortInUseException e) {

	    throw new Exception(e.getMessage());
	}
       
        sPort.sendBreak(1000);

	try {
	    setConnectionParameters();
	} catch (Exception e) {
	    sPort.close();
	    throw e;
	}

	try {
	    os = sPort.getOutputStream();
	    is = sPort.getInputStream();
	} catch (IOException e) {
	    sPort.close();
	    throw new Exception("Error opening i/o streams");
	}

	try {
	    sPort.addEventListener(this);
	} catch (TooManyListenersException e) {
	    sPort.close();
	    throw new Exception("too many listeners added");
	}

	sPort.notifyOnDataAvailable(true);
	sPort.notifyOnBreakInterrupt(true);

	try {
	    sPort.enableReceiveTimeout(30);
	} catch (UnsupportedCommOperationException e) {
	}

	portId.addPortOwnershipListener(this);

	open = true;
    }

    public void setConnectionParameters() throws Exception {

	int oldBaudRate = sPort.getBaudRate();
	int oldDatabits = sPort.getDataBits();
	int oldStopbits = sPort.getStopBits();
	int oldParity   = sPort.getParity();
	int oldFlowControl = sPort.getFlowControlMode();

	try {
	    sPort.setSerialPortParams(parameters.getBaudRate(),
				      parameters.getDatabits(),
				      parameters.getStopbits(),
				      parameters.getParity());
	} catch (UnsupportedCommOperationException e) {
	    parameters.setBaudRate(oldBaudRate);
	    parameters.setDatabits(oldDatabits);
	    parameters.setStopbits(oldStopbits);
	    parameters.setParity(oldParity);
	    throw new Exception("Unsupported parameter");
	}

	try {
	    sPort.setFlowControlMode(parameters.getFlowControlIn()
			           | parameters.getFlowControlOut());
	} catch (UnsupportedCommOperationException e) {
	    throw new Exception("Unsupported flow control");
	}
    }

    public void closeConnection() {
	if (!open) {
	    return;
	}

	if (sPort != null) {
	    try {

	    	os.close();
	    	is.close();
	    } catch (IOException e) {
		System.err.println(e);
	    }

	    sPort.close();

	    portId.removePortOwnershipListener(this);
	}

	open = false;
    }

    public void sendBreak() {
	sPort.sendBreak(1000);
    }

    public boolean isOpen() {
	return open;
    }

    public void serialEvent(SerialPortEvent e) {

	StringBuffer inputBuffer = new StringBuffer();
	int newData = 0;

	switch (e.getEventType()) {

	    case SerialPortEvent.DATA_AVAILABLE:
		    while (newData != -1) {
		    	try {
		    	    newData = is.read();
			    if (newData == -1) {
				break;
			    }
			    if ('\r' == (char)newData) {
			   	inputBuffer.append('\n');
			    } else {
			    	inputBuffer.append((char)newData);
			    }
		    	} catch (IOException ex) {
		    	    System.err.println(ex);
		    	    return;
		      	}
   		    }

		receptionString=(new String(inputBuffer));

                break;

	    case SerialPortEvent.BI:
		receptionString=receptionString+("\n--- BREAK RECEIVED ---\n");
	}

    }

    public void ownershipChange(int type) {

    }

    class KeyHandler extends KeyAdapter {
	OutputStream os;

	public KeyHandler(OutputStream os) {
	    
	    this.os = os;
	}

        @Override public void keyTyped(KeyEvent evt) {
            char newCharacter = evt.getKeyChar();
            if ((int)newCharacter==10) newCharacter = '\r';
            System.out.println ((int)newCharacter);
	    try {
	    	os.write((int)newCharacter);
	    } catch (IOException e) {
		System.err.println("OutputStream write error: " + e);
	    }
        }
    }
        public void send(String message) {
            byte[] theBytes= (message+"\n").getBytes();
            for (int i=0; i<theBytes.length;i++){

              char newCharacter = (char)theBytes[i];
              if ((int)newCharacter==10) newCharacter = '\r';

	      try {
	    	os.write((int)newCharacter);
              } catch (IOException e) {
                  System.err.println("OutputStream write error: " + e);
              }

            }

        }
}