Implement sending and receiving of events/commands

Author: juho05

src/main/java/org/codegame/client/Api.java

@@ -24,7 +24,7 @@ public class Api {
 	private boolean tls;
 	private String baseURL;
 
-	static Gson json = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
+	public static Gson json = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
 			.create();
 
 	public Api(String url) {
@@ -53,6 +53,10 @@ public GameInfo fetchInfo() throws IOException {
 		return fetchJSON("/api/info", GameInfo.class);
 	}
 
+	public static class GameConfigResponse<T> {
+		public T config;
+	}
+
 	public <T> T fetchGameConfig(String gameId, Class<T> configClass) throws IOException {
 		GameConfigResponse<T> response = fetchJSON("/api/games/" + gameId,
 				TypeToken.getParameterized(GameConfigResponse.class,

src/main/java/org/codegame/client/GameConfigResponse.java

@@ -3,15 +3,34 @@
 import java.io.IOException;
 import java.net.http.WebSocket;
 import java.util.HashMap;
+import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 
-import org.codegame.client.Api.GameInfo;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.reflect.TypeToken;
 
 public class GameSocket {
+	@FunctionalInterface
+	public interface EventCallback<T> {
+		void cb(T data);
+	}
+
+	private class Callbacks<T> {
+		Class<T> type;
+		HashMap<String, EventCallback<T>> callbacks;
+
+		Callbacks(Class<T> type) {
+			this.type = type;
+			this.callbacks = new HashMap<>();
+		}
+	}
+
 	private Api api;
 	private Session session = new Session();
 	private WebSocket websocket;
 	private HashMap<String, String> usernameCache = new HashMap<>();
+	@SuppressWarnings("rawtypes")
+	private HashMap<String, Callbacks> eventListeners = new HashMap<>();
 	private CountDownLatch exitEvent = new CountDownLatch(1);
 
 	public GameSocket(String url) {
@@ -77,7 +96,7 @@ public void connect(String gameId) throws IOException {
 		usernameCache = api.fetchPlayers(gameId);
 	}
 
-	public void block() {
+	public void listen() {
 		try {
 			exitEvent.await();
 		} catch (InterruptedException e) {
@@ -87,7 +106,67 @@ public void block() {
 
 	public void close() {
 		websocket.sendClose(WebSocket.NORMAL_CLOSURE, "Normal closure.");
-		block();
+		listen();
+	}
+
+	public static class Event<T> {
+		@SerializedName("name")
+		String name;
+		@SerializedName("data")
+		T data;
+
+		public Event() {
+		}
+
+		public Event(String name, T data) {
+			this.name = name;
+			this.data = data;
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	public <T> String on(String eventName, Class<T> type, EventCallback<T> callback) {
+		if (!eventListeners.containsKey(eventName))
+			eventListeners.put(eventName, new Callbacks<>(type));
+
+		var id = UUID.randomUUID().toString();
+		var callbacks = (Callbacks<T>) eventListeners.get(eventName);
+		if (!callbacks.type.getTypeName().equals(type.getTypeName()))
+			throw new IllegalArgumentException("Wrong event listener type.");
+		callbacks.type = type;
+		callbacks.callbacks.put(id, callback);
+		return id;
+	}
+
+	@SuppressWarnings("unchecked")
+	public <T> String once(String eventName, Class<T> type, EventCallback<T> callback) {
+		if (!eventListeners.containsKey(eventName))
+			eventListeners.put(eventName, new Callbacks<>(type));
+
+		var id = UUID.randomUUID().toString();
+		var callbacks = (Callbacks<T>) eventListeners.get(eventName);
+		if (!callbacks.type.getTypeName().equals(type.getTypeName()))
+			throw new IllegalArgumentException("Wrong event listener type.");
+		callbacks.type = type;
+		callbacks.callbacks.put(id, (data) -> {
+			callback.cb(data);
+			removeCallback(eventName, id);
+		});
+		return id;
+	}
+
+	public <T> void send(String commandName, T data) {
+		if (websocket == null || session.getPlayerId() == "")
+			throw new IllegalStateException("The socket is not connected to a player.");
+		Event<T> e = new Event<>(commandName, data);
+		var json = Api.json.toJson(e, TypeToken.getParameterized(Event.class, data.getClass()).getType());
+		websocket.sendText(json, true).join();
+	}
+
+	public void removeCallback(String eventName, String id) {
+		if (!eventListeners.containsKey(eventName))
+			return;
+		eventListeners.get(eventName).callbacks.remove(id);
 	}
 
 	public Api getApi() {
@@ -98,8 +177,21 @@ public Session getSession() {
 		return session;
 	}
 
+	private class EventMessage {
+		@SerializedName("name")
+		String name;
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
 	private void onMessage(String message) {
-		System.out.println("Received: " + message);
+		var emptyEvent = Api.json.fromJson(message, EventMessage.class);
+		if (!eventListeners.containsKey(emptyEvent.name))
+			return;
+		var callbacks = eventListeners.get(emptyEvent.name);
+		Event event = Api.json.fromJson(message, TypeToken.getParameterized(Event.class, callbacks.type).getType());
+		for (EventCallback cb : ((HashMap<String, EventCallback>) callbacks.callbacks).values()) {
+			cb.cb(event.data);
+		}
 	}
 
 	private void onClose() {