How to use org.atmosphere.websocket

/**
 * Use the underlying container's websocket to write the byte.
 *
 * @param b      a websocket byte message
 * @return this
 * @throws IOException
 */
public WebSocket write(byte[] b) throws IOException {
  return write(b, 0, b.length);
}

  @Override
  public void onError(WebSocket webSocket, WebSocketException t) {
    proxied.onError(webSocket,t);
  }
}

private void invokeInterceptors(WebSocketHandlerProxy webSocketHandler,
                WebSocket webSocket, Object webSocketMessageAsBody) throws IOException {
  invokeInterceptors(webSocketHandler, webSocket, webSocketMessageAsBody, 0, 0);
}

@Override
public WebSocket write(AtmosphereResponse r, byte[] data) throws IOException {
  if (data == null) {
    logger.error("Cannot write null value for {}", resource());
    return this;
  }
  return write(r, data, 0, data.length);
}

@Override
public void invokeWebSocketProtocol(WebSocket webSocket, Reader reader) {
  WebSocketHandlerProxy webSocketHandler = webSocketHandlerForMessage(webSocket);
  try {
    if (webSocketHandler == null) {
      if (WebSocketProtocolStream.class.isAssignableFrom(webSocketProtocol.getClass())) {
        List<AtmosphereRequest> list = WebSocketProtocolStream.class.cast(webSocketProtocol).onTextStream(webSocket, reader);
        dispatch(webSocket, list);
      } else {
        dispatchReader(webSocket, reader);
        return;
      }
    } else {
      if (WebSocketStreamingHandler.class.isAssignableFrom(webSocketHandler.proxied().getClass())) {
        if (invokeInterceptors) {
          invokeInterceptors(webSocketHandler, webSocket, reader);
        } else {
          WebSocketStreamingHandler.class.cast(webSocketHandler.proxied()).onTextStream(webSocket, reader);
        }
      } else {
        dispatchReader(webSocket, reader);
        return;
      }
    }
  } catch (Exception ex) {
    handleException(ex, webSocket, webSocketHandler);
  }
  notifyListener(webSocket, new WebSocketEventListener.WebSocketEvent<Reader>(reader, MESSAGE, webSocket));
}

@Override
public void invokeWebSocketProtocol(WebSocket webSocket, InputStream stream) {
  WebSocketHandlerProxy webSocketHandler = webSocketHandlerForMessage(webSocket);
  try {
    if (webSocketHandler == null) {
      if (WebSocketProtocolStream.class.isAssignableFrom(webSocketProtocol.getClass())) {
        List<AtmosphereRequest> list = WebSocketProtocolStream.class.cast(webSocketProtocol).onBinaryStream(webSocket, stream);
        dispatch(webSocket, list);
      } else {
        dispatchStream(webSocket, stream);
        return;
      }
    } else {
      if (WebSocketStreamingHandler.class.isAssignableFrom(webSocketHandler.proxied.getClass())) {
        if (invokeInterceptors) {
          invokeInterceptors(webSocketHandler, webSocket, stream);
        } else {
          WebSocketStreamingHandler.class.cast(webSocketHandler.proxied()).onBinaryStream(webSocket, stream);
        }
      } else {
        dispatchStream(webSocket, stream);
        return;
      }
    }
  } catch (Exception ex) {
    handleException(ex, webSocket, webSocketHandler);
  }
  notifyListener(webSocket, new WebSocketEventListener.WebSocketEvent<InputStream>(stream, MESSAGE, webSocket));
}

private void onDisconnect(WebSocketEvent event, AtmosphereResourceEventListener l) {
  if (event.webSocket() != null && event.webSocket().resource() != null) {
    framework.notifyDestroyed(event.webSocket().resource().uuid());
  }
  WebSocketEventListener.class.cast(l).onDisconnect(event);
}

public void executeClose(WebSocket webSocket, int closeCode) {
  AtmosphereResource r = webSocket.resource();
  boolean isClosedByClient = r == null ? true : r.getAtmosphereResourceEvent().isClosedByClient();
  try {
    if (r != null) {
      asynchronousProcessor.endRequest(AtmosphereResourceImpl.class.cast(r), true);
    }
  } finally {
    if (!isClosedByClient) {
      notifyListener(webSocket, new WebSocketEventListener.WebSocketEvent(closeCode, CLOSE, webSocket));
    }
  }
}

private void handleException(Exception ex, WebSocket webSocket, WebSocketHandler webSocketHandler) {
  logger.error("", ex);
  AtmosphereResource r = webSocket.resource();
  if (r != null) {
    webSocketHandler.onError(webSocket, new WebSocketException(ex,
        new AtmosphereResponseImpl.Builder()
            .request(r != null ? AtmosphereResourceImpl.class.cast(r).getRequest(false) : null)
            .status(500)
            .statusMessage("Server Error").build()));
  }
}

  @Override
  public void onError(javax.websocket.Session session, java.lang.Throwable t) {
    try {
      logger.debug("Problem in web socket session", t);
      webSocketProcessor.notifyListener(webSocket,
          new WebSocketEventListener.WebSocketEvent<Throwable>(t, WebSocketEventListener.WebSocketEvent.TYPE.EXCEPTION, webSocket));
    } catch (Exception ex) {
      // Ignore completely
      // https://github.com/Atmosphere/atmosphere/issues/1758
    }
  }
}

@Override
public void onPong(WebSocket webSocket, byte[] payload, int offset, int length) {
  WebSocketHandlerProxy webSocketHandler = webSocketHandlerForMessage(webSocket);
  if (webSocketHandler != null &&
      WebSocketPingPongListener.class.isAssignableFrom(webSocketHandler.proxied().getClass())) {
    WebSocketPingPongListener.class.cast(webSocketHandler.proxied()).onPong(webSocket, payload, offset, length);
  }
}

  @Override
  public void onPing(WebSocket webSocket, byte[] payload, int offset, int length) {
    WebSocketHandlerProxy webSocketHandler = webSocketHandlerForMessage(webSocket);

    if (webSocketHandler != null &&
        WebSocketPingPongListener.class.isAssignableFrom(webSocketHandler.proxied().getClass())) {
      WebSocketPingPongListener.class.cast(webSocketHandler.proxied()).onPing(webSocket, payload, offset, length);
    }
  }
}

void onClose(AtmosphereResourceEvent e) {
  for (AtmosphereResourceEventListener r : listeners) {
    r.onClose(e);
    if (transport.equals(TRANSPORT.WEBSOCKET) && WebSocketEventListener.class.isAssignableFrom(r.getClass())) {
      WebSocketEventListener.class.cast(r).onClose(new WebSocketEventListener.WebSocketEvent(1005, CLOSE, webSocket));
    }
  }
}

@Override
public void onTextMessage(WebSocket webSocket, String data) throws IOException {
  proxied.onTextMessage(webSocket, data);
}

@Override
public void onClose(WebSocket webSocket) {
  proxied.onClose(webSocket);
}

@Override
public void onOpen(WebSocket webSocket) throws IOException {
  proxied.onOpen(webSocket);
}

@Override
public void onByteMessage(WebSocket webSocket, byte[] data, int offset, int length) throws IOException {
  proxied.onByteMessage(webSocket,data,offset,length);
}

@Override
public WebSocketProcessor registerWebSocketHandler(String path, WebSocketHandlerProxy webSockethandler) {
  handlers.put(path, webSockethandler.path(path));
  return this;
}

public synchronized void destroy() {
  for (WebSocketProcessor processor : processors.values()) {
    processor.destroy();
  }
  processors.clear();
}

protected byte[] transform(byte[] b, int offset, int length) throws IOException {
  return transform(r.getResponse(), b, offset, length);
}