(
+ @SerializedName("code")
+ val code: Int = 0, // 200
+ @SerializedName("data")
+ val `data`: T?,
+ @SerializedName("msg")
+ val msg: String = "" // Successful request
+
+)
\ No newline at end of file
diff --git a/simple/src/main/res/drawable-v24/ic_launcher_foreground.xml b/simple/src/main/res/drawable-v24/ic_launcher_foreground.xml
new file mode 100644
index 0000000..c7bd21d
--- /dev/null
+++ b/simple/src/main/res/drawable-v24/ic_launcher_foreground.xml
@@ -0,0 +1,34 @@
+
+
+
+
+
+ * Legacy: Body\n\n^@
+ *
+ * Default: Body^@
+ *
+ * @param legacyWhitespace whether to append an extra two newlines
+ * @see The STOMP spec
+ */
+ public void setLegacyWhitespace(boolean legacyWhitespace) {
+ this.legacyWhitespace = legacyWhitespace;
+ }
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/client/StompedListenerRouter.java b/stomped-lib/src/main/java/com/stomped/stomped/client/StompedListenerRouter.java
new file mode 100644
index 0000000..2d13dd9
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/client/StompedListenerRouter.java
@@ -0,0 +1,52 @@
+package com.stomped.stomped.client;
+
+/*
+ * Description: This class will route incoming messages to
+ * the correct listeners. This way, a client who is subscribed
+ * to two different paths wont have to worry about the listeners
+ * catching messages from both subscriptions.
+ */
+
+import com.stomped.stomped.component.StompedFrame;
+import com.stomped.stomped.component.StompedHeaders;
+import com.stomped.stomped.listener.StompedListener;
+
+import java.util.HashMap;
+
+public class StompedListenerRouter {
+
+ private static final String TAG = "StompedListenerRouter";
+ private static StompedListenerRouter router;
+
+ private HashMap routingTable;
+
+ private StompedListenerRouter() {
+ routingTable = new HashMap<>();
+ }
+
+ public static synchronized StompedListenerRouter getInstance() {
+
+ if (router == null) {
+
+ router = new StompedListenerRouter();
+ }
+
+ return router;
+ }
+
+ public void addListener(StompedListener listener) {
+ routingTable.put(listener.getDestination(), listener);
+ }
+
+ public StompedListener removeListener(String key) {
+ return routingTable.remove(key);
+ }
+
+ public void sendMessage(StompedFrame frame) {
+ StompedListener currentListener = routingTable.get(frame.getHeaderValueFromKey(StompedHeaders.STOMP_HEADER_DESTINATION));
+
+ if (currentListener != null) {
+ currentListener.onNotify(frame);
+ }
+ }
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/client/StompedPayloadOperator.java b/stomped-lib/src/main/java/com/stomped/stomped/client/StompedPayloadOperator.java
new file mode 100644
index 0000000..19006f5
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/client/StompedPayloadOperator.java
@@ -0,0 +1,51 @@
+package com.stomped.stomped.client;
+
+import com.stomped.stomped.component.StompedFrame;
+import com.stomped.stomped.connection.WebSocketConnector;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+class StompedPayloadOperator implements Runnable {
+
+ private StompedFrame payload;
+ private WebSocketConnector connector;
+
+ public StompedPayloadOperator(StompedFrame payload, WebSocketConnector connector) {
+ this.payload = payload;
+ this.connector = connector;
+ }
+
+ @Override
+ public void run() {
+
+ try {
+
+ synchronized (connector.getMonitor()) {
+ if (!connector.isStompConnected()) {
+ connector.getMonitor().wait();
+ }
+ }
+
+ //A write method has to exist with the payload.builds return type.
+ Method method = WebSocketConnector.class.getDeclaredMethod("write", payload.build().getClass());
+ method.invoke(connector, payload.build());
+
+ } catch (NoSuchMethodException e) {
+
+ e.printStackTrace();
+
+ } catch (InvocationTargetException e) {
+
+ e.printStackTrace();
+
+ } catch (IllegalAccessException e) {
+
+ e.printStackTrace();
+
+ } catch (InterruptedException e) {
+
+ e.printStackTrace();
+ }
+ }
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/component/StompedCommand.java b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedCommand.java
new file mode 100644
index 0000000..551163a
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedCommand.java
@@ -0,0 +1,15 @@
+package com.stomped.stomped.component;
+
+public class StompedCommand {
+ public static final String STOMP_COMMAND_CONNECT = "CONNECT";
+ public static final String STOMP_COMMAND_CONNECTED = "CONNECTED";
+ public static final String STOMP_COMMAND_SEND = "SEND";
+ public static final String STOMP_COMMAND_SUBSCRIBE = "SUBSCRIBE";
+ public static final String STOMP_COMMAND_UNSUBSCRIBE = "UNSUBSCRIBE";
+ public static final String STOMP_COMMAND_ACK = "ACK";
+ public static final String STOMP_COMMAND_NACK = "NACK";
+ public static final String STOMP_COMMAND_BEGIN = "BEGIN";
+ public static final String STOMP_COMMAND_COMMIT = "COMMIT";
+ public static final String STOMP_COMMAND_ABORT = "ABORT";
+ public static final String STOMP_COMMAND_DISCONNECT = "DISCONNECT";
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/component/StompedFrame.java b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedFrame.java
new file mode 100644
index 0000000..6e86bb3
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedFrame.java
@@ -0,0 +1,114 @@
+package com.stomped.stomped.component;
+
+public class StompedFrame {
+
+ //TODO Change implementation of body.
+
+ private final static String TAG = "StompedFrame";
+ private String command;
+ private StompedHeaders headers;
+ private String body;
+ private String termination = "\u0000";
+ private boolean legacyWhitespace = true;
+
+ private StompedFrame() {
+ }
+
+ public static StompedFrame construct(String command) {
+ return construct(command, null);
+ }
+
+ public static StompedFrame construct(String command, StompedHeaders headers) {
+ return construct(command, headers, null);
+ }
+
+ public static StompedFrame construct(String command, StompedHeaders headers, String body) {
+
+ StompedFrame frame = new StompedFrame();
+ frame.setCommand(command);
+ frame.setStompedHeaders(headers);
+ frame.setStompedBody(body);
+
+ return frame;
+ }
+
+ public String build() {
+
+ StringBuilder builder = new StringBuilder();
+ builder.append(command);
+ builder.append("\n");
+
+ if (headers != null) {
+ builder.append(headers.getStringFormat());
+ }
+
+ builder.append("\n");
+
+ if (body != null) {
+ builder.append(body);
+ if (legacyWhitespace) {
+ builder.append("\n\n");
+ }
+ }
+ builder.append(termination);
+ return builder.toString();
+ }
+
+ public StompedHeaders createHeaders() {
+ headers = new StompedHeaders();
+ return headers;
+ }
+
+ public void addHeader(String key, String value) {
+ if (headers != null) {
+
+ headers.addHeader(key, value);
+ } else {
+
+ this.createHeaders().addHeader(key, value);
+ }
+ }
+
+ public String getHeaderValueFromKey(String key) {
+ return headers.getHeaderValueFromKey(key);
+ }
+
+ private void setCommand(String command) {
+ this.command = command;
+ }
+
+ private void setStompedHeaders(StompedHeaders headers) {
+ this.headers = headers;
+ }
+
+ private void setStompedBody(String body) {
+ this.body = body;
+ }
+
+ public String getCommand() {
+ return this.command;
+ }
+
+ public StompedHeaders getStompedHeaders() {
+ return this.headers;
+ }
+
+ public String getStompedBody() {
+ return this.body;
+ }
+
+ /**
+ * Reverts to the old frame formatting, which included two newlines between the message body
+ * and the end-of-frame marker.
+ *
+ * Legacy: Body\n\n^@
+ *
+ * Default: Body^@
+ *
+ * @param legacyWhitespace whether to append an extra two newlines
+ * @see The STOMP spec
+ */
+ public void setLegacyWhitespace(boolean legacyWhitespace) {
+ this.legacyWhitespace = legacyWhitespace;
+ }
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/component/StompedHeaders.java b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedHeaders.java
new file mode 100644
index 0000000..a21a1a6
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedHeaders.java
@@ -0,0 +1,62 @@
+package com.stomped.stomped.component;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public class StompedHeaders {
+
+ public final static String TAG = "StompedHeaders";
+ public final static String STOMP_HEADER_DESTINATION = "destination";
+ public final static String STOMP_HEADER_CONTENT_TYPE = "content-type";
+ public final static String STOMP_HEADER_SUB_ID = "id";
+ public final static String STOMP_HEADER_ACK = "ack";
+ public final static String STOMP_HEADER_HEARTBEAT = "heart-beat";
+ public final static String STOMP_HEADER_ACCEPT_VERSION = "accept-version";
+ public final static String STOMP_HEADER_HOST = "host";
+ public final static String STOMP_HEADER_RECEIPT = "receipt";
+
+ private TreeMap stompedHeaders;
+
+ private static final String HEADER_SEPARATOR = ":";
+
+ public StompedHeaders() {
+ this.stompedHeaders = new TreeMap<>();
+ }
+
+ public StompedHeaders(TreeMap stompedHeaders) {
+ this.stompedHeaders = stompedHeaders;
+ }
+
+ public void addHeader(String key, String value) {
+ stompedHeaders.put(key, value);
+ }
+
+ public TreeMap getStompedHeaders() {
+ return stompedHeaders;
+ }
+
+ public String getStringFormat() {
+
+ //Returns a string format of the Stomp Headers.
+
+ StringBuilder builder = new StringBuilder();
+
+ for (Map.Entry entry : stompedHeaders.entrySet()) {
+
+ builder.append(entry.getKey());
+ builder.append(HEADER_SEPARATOR);
+ builder.append(entry.getValue());
+ builder.append("\n");
+ }
+
+ return builder.toString();
+ }
+
+ public String getHeaderValueFromKey(String key) {
+ return stompedHeaders.get(key);
+ }
+
+ public boolean hasHeader(String header) {
+ return (stompedHeaders.get(header) != null);
+ }
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/component/StompedMessageParser.java b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedMessageParser.java
new file mode 100644
index 0000000..ca190c5
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/component/StompedMessageParser.java
@@ -0,0 +1,73 @@
+package com.stomped.stomped.component;
+
+
+import androidx.annotation.Nullable;
+
+import java.io.StringReader;
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class StompedMessageParser {
+
+ private final static String TAG = "StompedMessageParser";
+
+ private StompedMessageParser() {
+ }
+
+ public static StompedFrame constructFrame(String message) {
+
+ int currentPosition = 1;
+ String command;
+ StompedHeaders headers = new StompedHeaders();
+ StringBuilder body = new StringBuilder();
+
+ String[] splitMessage = message.split("\n");
+
+ command = splitMessage[0];
+
+ for (int i = currentPosition; i < splitMessage.length; i++) {
+ if (splitMessage[i].equals("")) {
+ currentPosition = i;
+ break;
+ } else {
+ String[] header = splitMessage[i].split(":");
+ headers.addHeader(header[0], header[1]);
+ }
+ }
+
+ for (int i = currentPosition; i < splitMessage.length; i++) {
+ body.append(splitMessage[i]);
+ }
+
+ return StompedFrame.construct(command, headers, body.toString());
+ }
+
+ public static final String TERMINATE_MESSAGE_SYMBOL = "\u0000";
+
+ private static final Pattern PATTERN_HEADER = Pattern.compile("([^:\\s]+)\\s*:\\s*([^:\\s]+)");
+
+ public static StompedFrame constructFrame2(@Nullable String data) {
+ if (data == null || data.trim().isEmpty()) {
+ return StompedFrame.construct("UNKNOWN");
+ }
+ Scanner reader = new Scanner(new StringReader(data));
+ reader.useDelimiter("\\n");
+ String command = reader.next();
+ StompedHeaders headers = new StompedHeaders();
+
+ while (reader.hasNext(PATTERN_HEADER)) {
+ Matcher matcher = PATTERN_HEADER.matcher(reader.next());
+ matcher.find();
+ headers.addHeader(matcher.group(1), matcher.group(2));
+ }
+
+ reader.skip("\\s");
+
+ reader.useDelimiter(TERMINATE_MESSAGE_SYMBOL);
+ String payload = reader.hasNext() ? reader.next() : null;
+
+ return StompedFrame.construct(command, headers, payload);
+ }
+
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/connection/WebSocketConnector.java b/stomped-lib/src/main/java/com/stomped/stomped/connection/WebSocketConnector.java
new file mode 100644
index 0000000..11de149
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/connection/WebSocketConnector.java
@@ -0,0 +1,158 @@
+package com.stomped.stomped.connection;
+
+import android.util.Log;
+
+import com.stomped.stomped.client.StompedClient;
+import com.stomped.stomped.client.StompedListenerRouter;
+import com.stomped.stomped.component.StompedCommand;
+import com.stomped.stomped.component.StompedFrame;
+import com.stomped.stomped.component.StompedHeaders;
+import com.stomped.stomped.component.StompedMessageParser;
+
+import java.util.concurrent.TimeUnit;
+
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.WebSocket;
+import okhttp3.WebSocketListener;
+import okio.ByteString;
+
+/*
+ * Description: Currently Stomped client is built over
+ * OkHttp WebSockets only. There are no ways to implement
+ * a different connection. //TODO Change this.
+ */
+
+public class WebSocketConnector {
+
+ private final static String TAG = WebSocketConnector.class.toString();
+
+ private final Object monitor = new Object();
+ private static WebSocket stompedWebSocket;
+ private Builder builder;
+ private boolean connected;
+ private boolean stompConnected;
+
+ private class OkWebSocketListener extends WebSocketListener {
+
+ @Override
+ public void onOpen(WebSocket webSocket, Response response) {
+
+ connected = true;
+ stompedWebSocket = webSocket;
+
+ StompedFrame frame = StompedFrame.construct(StompedCommand.STOMP_COMMAND_CONNECT);
+ frame.addHeader(StompedHeaders.STOMP_HEADER_ACCEPT_VERSION, "1.0,1.1,2.0");
+ frame.addHeader(StompedHeaders.STOMP_HEADER_HOST, "stomp.github.org");
+ frame.addHeader(StompedHeaders.STOMP_HEADER_HEARTBEAT, "0," + builder.heartBeat);
+ write(frame.build());
+
+ Log.d(TAG, "OkHttp WebSocket connection created.");
+ }
+
+ @Override
+ public void onMessage(WebSocket webSocket, String message) {
+
+ StompedFrame frame = StompedMessageParser.constructFrame2(message);
+
+ synchronized (monitor) {
+ if (frame.getCommand().equals(StompedCommand.STOMP_COMMAND_CONNECTED)) {
+ stompConnected = true;
+ monitor.notifyAll();
+ }
+ }
+
+ if (frame.getStompedHeaders().hasHeader(StompedHeaders.STOMP_HEADER_DESTINATION)) {
+ StompedListenerRouter.getInstance().sendMessage(frame);
+ }
+ if (StompedClient.isDebug) {
+ Log.d(TAG, "Message received from server");
+ }
+ }
+
+ @Override
+ public void onMessage(WebSocket webSocket, ByteString bytes) {
+ if (StompedClient.isDebug) {
+ Log.d(TAG, "ByteString message received");
+ }
+ }
+
+ @Override
+ public void onClosing(WebSocket webSocket, int code, String reason) {
+ if (StompedClient.isDebug) {
+ Log.d(TAG, "WebSocket is closing: " + reason);
+ }
+ }
+
+ @Override
+ public void onFailure(WebSocket webSocket, Throwable t, Response response) {
+ Log.d(TAG, "WebSocket failure\n", t);
+ }
+ }
+
+ public final static class Builder {
+
+ private int heartBeat = 0;
+
+ public WebSocketConnector connect(String url) {
+
+ WebSocketConnector connector = new WebSocketConnector(this);
+ connector.build(url);
+
+ return connector;
+ }
+
+ public Builder setHeartBeat(int milliseconds) {
+ this.heartBeat = milliseconds;
+ return this;
+ }
+ }
+
+ private WebSocketConnector(Builder builder) {
+ this.connected = false;
+ this.stompConnected = false;
+ this.builder = builder;
+ }
+
+ private WebSocketConnector build(String url) {
+
+ //Build the client
+ OkHttpClient okClient = new OkHttpClient.Builder()
+ .readTimeout(0, TimeUnit.MILLISECONDS)
+ .build();
+
+ //Build The Request
+ Request request = new Request.Builder()
+ .url(url)
+ .build();
+
+ okClient.newWebSocket(request, new OkWebSocketListener());
+
+ return this;
+ }
+
+ public void disconnect() {
+ stompedWebSocket.close(1000, null);
+ }
+
+ public void write(String payload) {
+ stompedWebSocket.send(payload);
+ }
+
+ public void write(ByteString payload) {
+ stompedWebSocket.send(payload);
+ }
+
+ public boolean isConnected() {
+ return connected;
+ }
+
+ public boolean isStompConnected() {
+ return stompConnected;
+ }
+
+ public Object getMonitor() {
+ return monitor;
+ }
+}
diff --git a/stomped-lib/src/main/java/com/stomped/stomped/listener/StompedListener.java b/stomped-lib/src/main/java/com/stomped/stomped/listener/StompedListener.java
new file mode 100644
index 0000000..7e49d67
--- /dev/null
+++ b/stomped-lib/src/main/java/com/stomped/stomped/listener/StompedListener.java
@@ -0,0 +1,28 @@
+package com.stomped.stomped.listener;
+
+import com.stomped.stomped.component.StompedFrame;
+
+public abstract class StompedListener {
+
+ private final static String TAG = "StompedListener";
+ private String destination;
+ private String destinationID;
+
+ public abstract void onNotify(final StompedFrame frame);
+
+ public void setDestination(String destination) {
+ this.destination = destination;
+ }
+
+ public String getDestination() {
+ return destination;
+ }
+
+ public void setDestinationID(String destinationID) {
+ this.destinationID = destinationID;
+ }
+
+ public String getDestinationID() {
+ return destinationID;
+ }
+}
diff --git a/stomped-lib/src/main/res/values/strings.xml b/stomped-lib/src/main/res/values/strings.xml
new file mode 100644
index 0000000..167f7bf
--- /dev/null
+++ b/stomped-lib/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+
+ stomped
+
diff --git a/stomped-lib/src/test/java/com/stomped/stomped/ExampleUnitTest.java b/stomped-lib/src/test/java/com/stomped/stomped/ExampleUnitTest.java
new file mode 100644
index 0000000..b84da18
--- /dev/null
+++ b/stomped-lib/src/test/java/com/stomped/stomped/ExampleUnitTest.java
@@ -0,0 +1,17 @@
+package com.stomped.stomped;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see Testing documentation
+ */
+public class ExampleUnitTest {
+ @Test
+ public void addition_isCorrect() throws Exception {
+ assertEquals(4, 2 + 2);
+ }
+}
\ No newline at end of file