add web module

.github/workflows/deploy.yml

@@ -0,0 +1,26 @@
+name: Build and Publish
+on: [ push, pull_request ]
+jobs:
+  build:
+    name: Test and Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Java
+        uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+
+      - name: Fetch Sources
+        uses: actions/checkout@v2
+
+      - name: Build
+        run: |
+          chmod +x ./gradlew
+          ./gradlew :messenger-web:browserWebpack
+
+      - name: Deploy
+        uses: JamesIves/github-pages-deploy-action@3.7.1
+        with:
+          BRANCH: gh-pages
+          FOLDER: messenger-web/build/distributions
+          CLEAN: true

build.gradle.kts

@@ -2,6 +2,12 @@ plugins {
     id("messenger")
 }
 
+allprojects {
+    repositories {
+        mavenCentral()
+    }
+}
+
 tasks {
     register("runClientAndServer") {
         dependsOn(":messenger-server:run")

messenger-api/build.gradle.kts

@@ -1,3 +1,7 @@
 plugins {
     id("messenger")
+}
+
+dependencies {
+    implementation("org.java-websocket:Java-WebSocket:1.5.3")
 }

messenger-api/src/main/java/io/frghackers/messenger/api/netzklassen/Client.java

@@ -1,142 +1,63 @@
 package io.frghackers.messenger.api.netzklassen;
 
 import io.frghackers.messenger.api.net.FriendlyBuffer;
+import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.handshake.ServerHandshake;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.net.Socket;
-
-/**
- * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
- *
- * <p>Klasse Client
- *
- * <p>Objekte von Unterklassen der abstrakten Klasse Client ermoeglichen Netzwerkverbindungen zu
- * einem Server mittels TCP/IP-Protokoll. Nach Verbindungsaufbau koennen Zeichenketten (Strings) zum
- * Server gesendet und von diesem empfangen werden, wobei der Nachrichtenempfang nebenlaeufig
- * geschieht. Zur Vereinfachung finden Nachrichtenversand und -empfang zeilenweise statt, d. h.,
- * beim Senden einer Zeichenkette wird ein Zeilentrenner ergaenzt und beim Empfang wird dieser
- * entfernt. Jede empfangene Nachricht wird einer Ereignisbehandlungsmethode uebergeben, die in
- * Unterklassen implementiert werden muss. Es findet nur eine rudimentaere Fehlerbehandlung statt,
- * so dass z.B. Verbindungsabbrueche nicht zu einem Programmabbruch fuehren. Eine einmal
- * unterbrochene oder getrennte Verbindung kann nicht reaktiviert werden.
- *
- * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
- * @version 30.08.2016
- */
-public abstract class Client {
-    private MessageHandler messageHandler;
-
-    private class MessageHandler extends Thread {
-        private SocketWrapper socketWrapper;
-        private boolean active;
-
-        private class SocketWrapper {
-            private Socket socket;
-            private DataInputStream fromServer;
-            private DataOutputStream toServer;
-
-            public SocketWrapper(String pServerIP, int pServerPort) {
-                try {
-                    socket = new Socket(pServerIP, pServerPort);
-                    toServer = new DataOutputStream(socket.getOutputStream());
-                    fromServer = new DataInputStream(socket.getInputStream());
-                } catch (IOException e) {
-                    socket = null;
-                    toServer = null;
-                    fromServer = null;
-                }
-            }
-
-            public byte[] receive() {
-                try {
-                    int length = fromServer.readInt();
-                    byte[] data = new byte[length];
-                    fromServer.readFully(data);
-
-                    return data;
-                } catch (IOException e) {
-                }
-
-                return null;
-            }
-
-            public void send(byte[] data) {
-                int len = data.length;
-
-                if (len <= 0) {
-                    throw new IllegalArgumentException("Data needs to have some data");
-                }
-
-                try {
-                    // write the length of the buffer
-                    toServer.writeInt(len);
-
-                    // Adjust the start index when needed
-                    toServer.write(data, 0, len);
-                } catch (IOException e) {
-                }
-            }
-
-            public void close() {
-                if (socket != null)
-                    try {
-                        socket.close();
-                    } catch (IOException e) {
-                        /*
-                         * Falls eine Verbindung getrennt werden soll, deren Endpunkt
-                         * nicht mehr existiert bzw. ihrerseits bereits beendet worden ist,
-                         * geschieht nichts.
-                         */
-                    }
-            }
-        }
-
-        private MessageHandler(String pServerIP, int pServerPort) {
-            socketWrapper = new SocketWrapper(pServerIP, pServerPort);
-            start();
-            if (socketWrapper.socket != null) active = true;
-        }
-
-        public void run() {
-            byte[] message;
-            while (active) {
-                message = socketWrapper.receive();
-                processMessage(new FriendlyBuffer(message));
-            }
-        }
-
-        private void send(byte[] pMessage) {
-            if (active) socketWrapper.send(pMessage);
-        }
-
-        private void close() {
-            if (active) {
-                active = false;
-                socketWrapper.close();
-            }
-        }
-    }
+import java.net.URI;
+import java.nio.ByteBuffer;
+
+
+public abstract class Client extends WebSocketClient {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
 
     public Client(String pServerIP, int pServerPort) {
-        messageHandler = new MessageHandler(pServerIP, pServerPort);
+        super(URI.create("ws://%s:%d".formatted(pServerIP, pServerPort)));
+        this.connect();
+    }
+
+    @Override
+    public void onOpen(ServerHandshake handshakedata) {
+        logger.info("Connection opened");
+    }
+
+    @Override
+    public void onMessage(ByteBuffer bytes) {
+        logger.info("new bmsg: " + bytes.toString());
+        processMessage(new FriendlyBuffer(bytes));
+    }
+
+    @Override
+    public void onMessage(String message) {
+        logger.info("new msg: " + message);
+    }
+
+    @Override
+    public void onClose(int code, String reason, boolean remote) {
+    }
+
+    @Override
+    public void onError(Exception ex) {
+
     }
 
     public boolean isConnected() {
-        return (messageHandler.active);
+        return true;
     }
 
     public void send(FriendlyBuffer _buffer) {
         send(_buffer.toByteArray());
     }
 
     public void send(byte[] pMessage) {
-        messageHandler.send(pMessage);
+        super.send(pMessage);
     }
 
     public void close() {
-        messageHandler.close();
+        super.close();
     }
 
     public abstract void processMessage(FriendlyBuffer _message);