diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 00000000..7bbbc83a --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,63 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: 'bug' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** + +Please fill the following code example: + +Socket.IO server version: `x.y.z` + +*Server* + +```js +import { Server } from "socket.io"; + +const io = new Server(8080); + +io.on("connection", (socket) => { + // ... +}); +``` + +Socket.IO java client version: `x.y.z` + +*Client* + +```java +public class MyApplication { + public static void main(String[] args) throws URISyntaxException { + IO.Options options = IO.Options.builder() + .build(); + + Socket socket = IO.socket("http://localhost:8080", options); + + socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println("connect"); + } + }); + + socket.open(); + } +} +``` + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Platform:** + - Device: [e.g. Samsung S8] + - OS: [e.g. Android 9.2] + +**Additional context** +Add any other context about the problem here. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..36014cde --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,20 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: 'enhancement' +assignees: '' + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md new file mode 100644 index 00000000..53c39215 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/question.md @@ -0,0 +1,9 @@ +--- +name: Ask a Question +about: Ask the community for help +title: '' +labels: 'question' +assignees: '' + +--- + diff --git a/History.md b/History.md index a393673e..02f66f43 100644 --- a/History.md +++ b/History.md @@ -1,4 +1,15 @@ +2.0.1 / 2021-04-27 +================== + +### Bug Fixes + +* fix usage with ws:// scheme ([67fd5f3](https://github.com/socketio/socket.io-client-java/commit/67fd5f34a31c63f7884f82ab39386ad343527590)) +* ensure buffered events are sent in order ([4885e7d](https://github.com/socketio/socket.io-client-java/commit/4885e7d59fad78285448694cb5681e8a9ce809ef)) +* ensure the payload format is valid ([e8ffe9d](https://github.com/socketio/socket.io-client-java/commit/e8ffe9d1383736f6a21090ab959a2f4fa5a41284)) +* emit a CONNECT_ERROR event upon connection failure ([d324e7f](https://github.com/socketio/socket.io-client-java/commit/d324e7f396a444ddd556c3d70a85a28eefb1e02b)) + + 2.0.0 / 2020-12-15 ================== diff --git a/Makefile b/Makefile index cc752f8b..d0927070 100644 --- a/Makefile +++ b/Makefile @@ -2,6 +2,6 @@ help: ## print this message @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' build-site: ## build the site - mvn javadoc:javadoc site -DskipTests + mvn clean javadoc:javadoc site -DskipTests .PHONY: build-site diff --git a/README.md b/README.md index 41a4705a..28c73c09 100644 --- a/README.md +++ b/README.md @@ -2,9 +2,7 @@ [![Build Status](https://github.com/socketio/socket.io-client-java/workflows/CI/badge.svg)](https://github.com/socketio/socket.io-client-java/actions) -This is the Socket.IO v1.x and v2.x Client Library for Java, which is simply ported from the [JavaScript client](https://github.com/socketio/socket.io-client). - -**Does not yet support Socket:IO v3.x, use v2.x instead!** +This is the Socket.IO Client Library for Java, which is simply ported from the [JavaScript client](https://github.com/socketio/socket.io-client). See also: @@ -14,11 +12,7 @@ See also: ## Table of content - [Compatibility](#compatibility) -- [Installation](#installation) - - [Maven](#maven) - - [Gradle](#gradle) -- [Usage](#usage) -- [Features](#features) +- [Documentation](#documentation) - [License](#license) ## Compatibility @@ -27,182 +21,13 @@ See also: | -------------- | ---------------- | | 0.9.x | 1.x | | 1.x | 2.x | -| 2.x | 3.x | - -## Installation -The latest artifact is available on Maven Central. - -### Maven -Add the following dependency to your `pom.xml`. - -```xml - - - io.socket - socket.io-client - 2.0.0 - - -``` - -### Gradle -Add it as a gradle dependency for Android Studio, in `build.gradle`: - -```groovy -compile ('io.socket:socket.io-client:2.0.0') { - // excluding org.json which is provided by Android - exclude group: 'org.json', module: 'json' -} -``` - -## Usage -Socket.IO-client Java has almost the same api and features with the original JS client. You use `IO#socket` to initialize `Socket`: - -```java -import io.socket.client.IO; -import io.socket.client.Socket; -... - -Socket socket = IO.socket("http://localhost"); -socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { - - @Override - public void call(Object... args) { - socket.emit("foo", "hi"); - socket.disconnect(); - } - -}).on("event", new Emitter.Listener() { - - @Override - public void call(Object... args) {} - -}).on(Socket.EVENT_DISCONNECT, new Emitter.Listener() { - - @Override - public void call(Object... args) {} - -}); -socket.connect(); -``` - -This Library uses [org.json](https://github.com/stleary/JSON-java) to parse and compose JSON strings: - -```java -// Sending an object -JSONObject obj = new JSONObject(); -obj.put("hello", "server"); -obj.put("binary", new byte[42]); -socket.emit("foo", obj); - -// Receiving an object -socket.on("foo", new Emitter.Listener() { - @Override - public void call(Object... args) { - JSONObject obj = (JSONObject)args[0]; - } -}); -``` - -Options are supplied as follows: - -```java -IO.Options opts = new IO.Options(); -opts.forceNew = true; -opts.reconnection = false; - -socket = IO.socket("http://localhost", opts); -``` - -You can supply query parameters with the `query` option. NB: if you don't want to reuse a cached socket instance when the query parameter changes, you should use the `forceNew` option, the use case might be if your app allows for a user to logout, and a new user to login again: - -```java -IO.Options opts = new IO.Options(); -opts.forceNew = true; -opts.query = "auth_token=" + authToken; -Socket socket = IO.socket("http://localhost", opts); -``` - -You can get a callback with `Ack` when the server received a message: - -```java -socket.emit("foo", "woot", new Ack() { - @Override - public void call(Object... args) {} -}); -``` - -And vice versa: - -```java -// ack from client to server -socket.on("foo", new Emitter.Listener() { - @Override - public void call(Object... args) { - Ack ack = (Ack) args[args.length - 1]; - ack.call(); - } -}); -``` - -SSL (HTTPS, WSS) settings: - -```java -OkHttpClient okHttpClient = new OkHttpClient.Builder() - .hostnameVerifier(myHostnameVerifier) - .sslSocketFactory(mySSLContext.getSocketFactory(), myX509TrustManager) - .build(); - -// default settings for all sockets -IO.setDefaultOkHttpWebSocketFactory(okHttpClient); -IO.setDefaultOkHttpCallFactory(okHttpClient); - -// set as an option -opts = new IO.Options(); -opts.callFactory = okHttpClient; -opts.webSocketFactory = okHttpClient; -socket = IO.socket("https://localhost", opts); -``` - -See the Javadoc for more details. - -http://socketio.github.io/socket.io-client-java/apidocs/ - -### Transports and HTTP Headers -You can access transports and their HTTP headers as follows. - -```java -// Called upon transport creation. -socket.io().on(Manager.EVENT_TRANSPORT, new Emitter.Listener() { - @Override - public void call(Object... args) { - Transport transport = (Transport)args[0]; +| 2.x | 3.x / 4.x | - transport.on(Transport.EVENT_REQUEST_HEADERS, new Emitter.Listener() { - @Override - public void call(Object... args) { - @SuppressWarnings("unchecked") - Map> headers = (Map>)args[0]; - // modify request headers - headers.put("Cookie", Arrays.asList("foo=1;")); - } - }); +## Documentation - transport.on(Transport.EVENT_RESPONSE_HEADERS, new Emitter.Listener() { - @Override - public void call(Object... args) { - @SuppressWarnings("unchecked") - Map> headers = (Map>)args[0]; - // access response headers - String cookie = headers.get("Set-Cookie").get(0); - } - }); - } -}); -``` +The documentation can be found [here](https://socketio.github.io/socket.io-client-java/installation.html). -## Features -This library supports all of the features the JS client does, including events, options and upgrading transport. Android is fully supported. +The source of this documentation is in the `src/site/` directory of the repository. Pull requests are welcome! ## License diff --git a/pom.xml b/pom.xml index 7da6dcdd..66b4d2f2 100644 --- a/pom.xml +++ b/pom.xml @@ -2,7 +2,7 @@ 4.0.0 io.socket socket.io-client - 2.0.0 + 2.0.1 jar socket.io-client Socket.IO Client Library for Java @@ -30,7 +30,7 @@ https://github.com/socketio/socket.io-client-java scm:git:https://github.com/socketio/socket.io-client-java.git scm:git:https://github.com/socketio/socket.io-client-java.git - socket.io-client-2.0.0 + socket.io-client-2.0.1 diff --git a/src/main/java/io/socket/client/Ack.java b/src/main/java/io/socket/client/Ack.java index 8bd6a1e8..592838cb 100644 --- a/src/main/java/io/socket/client/Ack.java +++ b/src/main/java/io/socket/client/Ack.java @@ -5,7 +5,7 @@ */ public interface Ack { - public void call(Object... args); + void call(Object... args); } diff --git a/src/main/java/io/socket/client/IO.java b/src/main/java/io/socket/client/IO.java index e307b6e0..1da0c197 100644 --- a/src/main/java/io/socket/client/IO.java +++ b/src/main/java/io/socket/client/IO.java @@ -7,7 +7,6 @@ import java.net.URI; import java.net.URISyntaxException; -import java.net.URL; import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Level; import java.util.logging.Logger; @@ -17,7 +16,7 @@ public class IO { private static final Logger logger = Logger.getLogger(IO.class.getName()); - private static final ConcurrentHashMap managers = new ConcurrentHashMap(); + private static final ConcurrentHashMap managers = new ConcurrentHashMap<>(); /** * Protocol version. @@ -58,21 +57,16 @@ public static Socket socket(URI uri, Options opts) { opts = new Options(); } - URL parsed = Url.parse(uri); - URI source; - try { - source = parsed.toURI(); - } catch (URISyntaxException e) { - throw new RuntimeException(e); - } - String id = Url.extractId(parsed); - String path = parsed.getPath(); + Url.ParsedURI parsed = Url.parse(uri); + URI source = parsed.uri; + String id = parsed.id; + boolean sameNamespace = managers.containsKey(id) - && managers.get(id).nsps.containsKey(path); + && managers.get(id).nsps.containsKey(source.getPath()); boolean newConnection = opts.forceNew || !opts.multiplex || sameNamespace; Manager io; - String query = parsed.getQuery(); + String query = source.getQuery(); if (query != null && (opts.query == null || opts.query.isEmpty())) { opts.query = query; } @@ -92,7 +86,7 @@ public static Socket socket(URI uri, Options opts) { io = managers.get(id); } - return io.socket(parsed.getPath(), opts); + return io.socket(source.getPath(), opts); } diff --git a/src/main/java/io/socket/client/Manager.java b/src/main/java/io/socket/client/Manager.java index 67c2f704..a3c5f19e 100644 --- a/src/main/java/io/socket/client/Manager.java +++ b/src/main/java/io/socket/client/Manager.java @@ -114,8 +114,8 @@ public Manager(URI uri, Options opts) { opts.callFactory = defaultCallFactory; } this.opts = opts; - this.nsps = new ConcurrentHashMap(); - this.subs = new LinkedList(); + this.nsps = new ConcurrentHashMap<>(); + this.subs = new LinkedList<>(); this.reconnection(opts.reconnection); this.reconnectionAttempts(opts.reconnectionAttempts != 0 ? opts.reconnectionAttempts : Integer.MAX_VALUE); this.reconnectionDelay(opts.reconnectionDelay != 0 ? opts.reconnectionDelay : 1000); @@ -129,7 +129,7 @@ public Manager(URI uri, Options opts) { this.readyState = ReadyState.CLOSED; this.uri = uri; this.encoding = false; - this.packetBuffer = new ArrayList(); + this.packetBuffer = new ArrayList<>(); this.encoder = opts.encoder != null ? opts.encoder : new IOParser.Encoder(); this.decoder = opts.decoder != null ? opts.decoder : new IOParser.Decoder(); } @@ -271,23 +271,28 @@ public void call(Object... objects) { } }); - if (Manager.this._timeout >= 0) { - final long timeout = Manager.this._timeout; + final long timeout = Manager.this._timeout; + final Runnable onTimeout = new Runnable() { + @Override + public void run() { + logger.fine(String.format("connect attempt timed out after %d", timeout)); + openSub.destroy(); + socket.close(); + socket.emit(Engine.EVENT_ERROR, new SocketIOException("timeout")); + } + }; + + if (timeout == 0) { + EventThread.exec(onTimeout); + return; + } else if (Manager.this._timeout > 0) { logger.fine(String.format("connection attempt will timeout after %d", timeout)); final Timer timer = new Timer(); timer.schedule(new TimerTask() { @Override public void run() { - EventThread.exec(new Runnable() { - @Override - public void run() { - logger.fine(String.format("connect attempt timed out after %d", timeout)); - openSub.destroy(); - socket.close(); - socket.emit(Engine.EVENT_ERROR, new SocketIOException("timeout")); - } - }); + EventThread.exec(onTimeout); } }, timeout); @@ -321,10 +326,14 @@ private void onopen() { @Override public void call(Object... objects) { Object data = objects[0]; - if (data instanceof String) { - Manager.this.ondata((String)data); - } else if (data instanceof byte[]) { - Manager.this.ondata((byte[])data); + try { + if (data instanceof String) { + Manager.this.decoder.add((String) data); + } else if (data instanceof byte[]) { + Manager.this.decoder.add((byte[]) data); + } + } catch (DecodingException e) { + logger.fine("error while decoding the packet: " + e.getMessage()); } } })); @@ -348,22 +357,6 @@ public void call (Packet packet) { }); } - private void ondata(String data) { - try { - this.decoder.add(data); - } catch (DecodingException e) { - this.onerror(e); - } - } - - private void ondata(byte[] data) { - try { - this.decoder.add(data); - } catch (DecodingException e) { - this.onerror(e); - } - } - private void ondecoded(Packet packet) { this.emit(EVENT_PACKET, packet); } @@ -550,9 +543,9 @@ private void onreconnect() { } - public static interface OpenCallback { + public interface OpenCallback { - public void call(Exception err); + void call(Exception err); } diff --git a/src/main/java/io/socket/client/On.java b/src/main/java/io/socket/client/On.java index b962f131..26b46f34 100644 --- a/src/main/java/io/socket/client/On.java +++ b/src/main/java/io/socket/client/On.java @@ -16,8 +16,8 @@ public void destroy() { }; } - public static interface Handle { + public interface Handle { - public void destroy(); + void destroy(); } } diff --git a/src/main/java/io/socket/client/Socket.java b/src/main/java/io/socket/client/Socket.java index 203c61f4..05feff39 100644 --- a/src/main/java/io/socket/client/Socket.java +++ b/src/main/java/io/socket/client/Socket.java @@ -58,10 +58,10 @@ public class Socket extends Emitter { private String nsp; private Manager io; private Map auth; - private Map acks = new HashMap(); + private Map acks = new HashMap<>(); private Queue subs; - private final Queue> receiveBuffer = new LinkedList>(); - private final Queue> sendBuffer = new LinkedList>(); + private final Queue> receiveBuffer = new LinkedList<>(); + private final Queue> sendBuffer = new LinkedList<>(); public Socket(Manager io, String nsp, Manager.Options opts) { this.io = io; @@ -91,7 +91,9 @@ public void call(Object... args) { add(On.on(io, Manager.EVENT_ERROR, new Listener() { @Override public void call(Object... args) { - Socket.super.emit(EVENT_CONNECT_ERROR, args[0]); + if (!Socket.this.connected) { + Socket.super.emit(EVENT_CONNECT_ERROR, args[0]); + } } })); add(On.on(io, Manager.EVENT_CLOSE, new Listener() { @@ -205,7 +207,7 @@ public void run() { } } - Packet packet = new Packet(Parser.EVENT, jsonArgs); + Packet packet = new Packet<>(Parser.EVENT, jsonArgs); if (ack != null) { logger.fine(String.format("emitting packet with ack id %d", ids)); @@ -302,7 +304,7 @@ private void onpacket(Packet packet) { } private void onevent(Packet packet) { - List args = new ArrayList(Arrays.asList(toArray(packet.data))); + List args = new ArrayList<>(Arrays.asList(toArray(packet.data))); if (logger.isLoggable(Level.FINE)) { logger.fine(String.format("emitting event %s", args)); } @@ -341,7 +343,7 @@ public void run() { jsonArgs.put(arg); } - Packet packet = new Packet(Parser.ACK, jsonArgs); + Packet packet = new Packet<>(Parser.ACK, jsonArgs); packet.id = id; self.packet(packet); } @@ -367,8 +369,8 @@ private void onack(Packet packet) { private void onconnect(String id) { this.connected = true; this.id = id; - super.emit(EVENT_CONNECT); this.emitBuffered(); + super.emit(EVENT_CONNECT); } private void emitBuffered() { diff --git a/src/main/java/io/socket/client/Url.java b/src/main/java/io/socket/client/Url.java index c9185d29..451eee8b 100644 --- a/src/main/java/io/socket/client/Url.java +++ b/src/main/java/io/socket/client/Url.java @@ -1,16 +1,11 @@ package io.socket.client; -import java.net.MalformedURLException; import java.net.URI; -import java.net.URISyntaxException; -import java.net.URL; -import java.util.regex.Pattern; import java.util.regex.Matcher; +import java.util.regex.Pattern; public class Url { - private static Pattern PATTERN_HTTP = Pattern.compile("^http|ws$"); - private static Pattern PATTERN_HTTPS = Pattern.compile("^(http|ws)s$"); /** * Expected format: "[id:password@]host[:port]" */ @@ -18,11 +13,17 @@ public class Url { private Url() {} - public static URL parse(String uri) throws URISyntaxException { - return parse(new URI(uri)); + static class ParsedURI { + public final URI uri; + public final String id; + + public ParsedURI(URI uri, String id) { + this.uri = uri; + this.id = id; + } } - public static URL parse(URI uri) { + public static ParsedURI parse(URI uri) { String protocol = uri.getScheme(); if (protocol == null || !protocol.matches("^https?|wss?$")) { protocol = "https"; @@ -30,9 +31,9 @@ public static URL parse(URI uri) { int port = uri.getPort(); if (port == -1) { - if (PATTERN_HTTP.matcher(protocol).matches()) { + if ("http".equals(protocol) || "ws".equals(protocol)) { port = 80; - } else if (PATTERN_HTTPS.matcher(protocol).matches()) { + } else if ("https".equals(protocol) || "wss".equals(protocol)) { port = 443; } } @@ -50,35 +51,18 @@ public static URL parse(URI uri) { // might happen on some of Samsung Devices such as S4. _host = extractHostFromAuthorityPart(uri.getRawAuthority()); } - try { - return new URL(protocol + "://" - + (userInfo != null ? userInfo + "@" : "") - + _host - + (port != -1 ? ":" + port : "") - + path - + (query != null ? "?" + query : "") - + (fragment != null ? "#" + fragment : "")); - } catch (MalformedURLException e) { - throw new RuntimeException(e); - } - } - - public static String extractId(String url) throws MalformedURLException { - return extractId(new URL(url)); + URI completeUri = URI.create(protocol + "://" + + (userInfo != null ? userInfo + "@" : "") + + _host + + (port != -1 ? ":" + port : "") + + path + + (query != null ? "?" + query : "") + + (fragment != null ? "#" + fragment : "")); + String id = protocol + "://" + _host + ":" + port; + + return new ParsedURI(completeUri, id); } - public static String extractId(URL url) { - String protocol = url.getProtocol(); - int port = url.getPort(); - if (port == -1) { - if (PATTERN_HTTP.matcher(protocol).matches()) { - port = 80; - } else if (PATTERN_HTTPS.matcher(protocol).matches()) { - port = 443; - } - } - return protocol + "://" + url.getHost() + ":" + port; - } private static String extractHostFromAuthorityPart(String authority) { diff --git a/src/main/java/io/socket/parser/Binary.java b/src/main/java/io/socket/parser/Binary.java index b390da62..3ef17116 100644 --- a/src/main/java/io/socket/parser/Binary.java +++ b/src/main/java/io/socket/parser/Binary.java @@ -20,7 +20,7 @@ public class Binary { @SuppressWarnings("unchecked") public static DeconstructedPacket deconstructPacket(Packet packet) { - List buffers = new ArrayList(); + List buffers = new ArrayList<>(); packet.data = _deconstructPacket(packet.data, buffers); packet.attachments = buffers.size(); diff --git a/src/main/java/io/socket/parser/IOParser.java b/src/main/java/io/socket/parser/IOParser.java index 49c1bc8b..e9c53459 100644 --- a/src/main/java/io/socket/parser/IOParser.java +++ b/src/main/java/io/socket/parser/IOParser.java @@ -1,7 +1,9 @@ package io.socket.parser; import io.socket.hasbinary.HasBinary; +import org.json.JSONArray; import org.json.JSONException; +import org.json.JSONObject; import org.json.JSONTokener; import java.util.ArrayList; @@ -122,7 +124,7 @@ private static Packet decodeString(String str) { int i = 0; int length = str.length(); - Packet p = new Packet(Character.getNumericValue(str.charAt(0))); + Packet p = new Packet<>(Character.getNumericValue(str.charAt(0))); if (p.type < 0 || p.type > types.length - 1) { throw new DecodingException("unknown packet type " + p.type); @@ -183,6 +185,9 @@ private static Packet decodeString(String str) { logger.log(Level.WARNING, "An error occured while retrieving data from JSONTokener", e); throw new DecodingException("invalid payload"); } + if (!isPayloadValid(p.type, p.data)) { + throw new DecodingException("invalid payload"); + } } if (logger.isLoggable(Level.FINE)) { @@ -191,6 +196,26 @@ private static Packet decodeString(String str) { return p; } + private static boolean isPayloadValid(int type, Object payload) { + switch (type) { + case Parser.CONNECT: + case Parser.CONNECT_ERROR: + return payload instanceof JSONObject; + case Parser.DISCONNECT: + return payload == null; + case Parser.EVENT: + case Parser.BINARY_EVENT: + return payload instanceof JSONArray + && ((JSONArray) payload).length() > 0 + && !((JSONArray) payload).isNull(0); + case Parser.ACK: + case Parser.BINARY_ACK: + return payload instanceof JSONArray; + default: + return false; + } + } + @Override public void destroy() { if (this.reconstructor != null) { @@ -214,7 +239,7 @@ public void onDecoded (Callback callback) { BinaryReconstructor(Packet packet) { this.reconPack = packet; - this.buffers = new ArrayList(); + this.buffers = new ArrayList<>(); } public Packet takeBinaryData(byte[] binData) { @@ -230,7 +255,7 @@ public Packet takeBinaryData(byte[] binData) { public void finishReconstruction () { this.reconPack = null; - this.buffers = new ArrayList(); + this.buffers = new ArrayList<>(); } } } diff --git a/src/main/java/io/socket/parser/Parser.java b/src/main/java/io/socket/parser/Parser.java index 73635e3c..ea4f6285 100644 --- a/src/main/java/io/socket/parser/Parser.java +++ b/src/main/java/io/socket/parser/Parser.java @@ -5,44 +5,44 @@ public interface Parser { /** * Packet type `connect`. */ - public static final int CONNECT = 0; + int CONNECT = 0; /** * Packet type `disconnect`. */ - public static final int DISCONNECT = 1; + int DISCONNECT = 1; /** * Packet type `event`. */ - public static final int EVENT = 2; + int EVENT = 2; /** * Packet type `ack`. */ - public static final int ACK = 3; + int ACK = 3; /** * Packet type `error`. */ - public static final int CONNECT_ERROR = 4; + int CONNECT_ERROR = 4; /** * Packet type `binary event`. */ - public static final int BINARY_EVENT = 5; + int BINARY_EVENT = 5; /** * Packet type `binary ack`. */ - public static final int BINARY_ACK = 6; + int BINARY_ACK = 6; - public static int protocol = 5; + int protocol = 5; /** * Packet types. */ - public static String[] types = new String[] { + String[] types = new String[] { "CONNECT", "DISCONNECT", "EVENT", @@ -52,29 +52,29 @@ public interface Parser { "BINARY_ACK" }; - public static interface Encoder { + interface Encoder { - public void encode(Packet obj, Callback callback); + void encode(Packet obj, Callback callback); - public interface Callback { + interface Callback { - public void call(Object[] data); + void call(Object[] data); } } - public static interface Decoder { + interface Decoder { - public void add(String obj); + void add(String obj); - public void add(byte[] obj); + void add(byte[] obj); - public void destroy(); + void destroy(); - public void onDecoded(Callback callback); + void onDecoded(Callback callback); - public interface Callback { + interface Callback { - public void call(Packet packet); + void call(Packet packet); } } } diff --git a/src/site/markdown/changelog.md b/src/site/markdown/changelog.md new file mode 100644 index 00000000..98ea025b --- /dev/null +++ b/src/site/markdown/changelog.md @@ -0,0 +1,18 @@ + +## [2.0.0](https://github.com/socketio/socket.io-client-java/compare/socket.io-client-1.0.1...socket.io-client-2.0.0) (2020-12-14) + + +### Features + +* add options builder ([#304](https://github.com/socketio/socket.io-client-java/issues/304)) ([49068d3](https://github.com/socketio/socket.io-client-java/commit/49068d3cc504c9b83e29a8d5cb4350360c6ef8ea)) +* add support for Socket.IO v3 ([79cb27f](https://github.com/socketio/socket.io-client-java/commit/79cb27fc979ecf1eec9dc2dd4a72c8081149d1e2)), closes [/github.com/socketio/socket.io-protocol#difference-between-v5-and-v4](https://github.com//github.com/socketio/socket.io-protocol/issues/difference-between-v5-and-v4) + + + +## [1.0.1](https://github.com/socketio/socket.io-client-java/compare/socket.io-client-1.0.0...socket.io-client-1.0.1) (2020-12-10) + + +### Bug Fixes + +* don't process socket.connect() if we are already re-connecting ([#577](https://github.com/socketio/socket.io-client-java/issues/577)) ([54b7311](https://github.com/socketio/socket.io-client-java/commit/54b73114d19f33a78bec1ce99325893129f8a148)) +* handle case where URI.getHost() returns null ([#484](https://github.com/socketio/socket.io-client-java/issues/484)) ([567372e](https://github.com/socketio/socket.io-client-java/commit/567372ecfa6c86bdc72f8bc64985d6511dc87666)) diff --git a/src/site/markdown/emitting_events.md b/src/site/markdown/emitting_events.md new file mode 100644 index 00000000..fce31092 --- /dev/null +++ b/src/site/markdown/emitting_events.md @@ -0,0 +1,105 @@ +# Emitting events + +See also: https://socket.io/docs/v3/emitting-events/ + +**Table of content** + + + +There are several ways to send events between the server and the client. + +## Basic emit + +The Socket.IO API is inspired from the Node.js [EventEmitter](https://nodejs.org/docs/latest/api/events.html#events_events): + +*Server* + +```js +io.on("connection", (socket) => { + socket.emit("hello", "world"); +}); +``` + +*Client* + +```java +socket.on("hello", new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println(args[0]); // world + } +}); +``` + +This also works in the other direction: + +*Server* + +```js +io.on("connection", (socket) => { + socket.on("hello", (arg) => { + console.log(arg); // world + }); +}); +``` + +*Client* + +```java +socket.emit("hello", "world"); +``` + +You can send any number of arguments, and all serializable datastructures are supported, including binary objects like [Buffer](https://nodejs.org/docs/latest/api/buffer.html#buffer_buffer) or [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray). + +*Server* + +```js +io.on("connection", (socket) => { + socket.on("hello", (...args) => { + console.log(args); // [ 1, '2', , { test: '42' } ] + }); +}); +``` + +*Client* + +```java +byte[] buffer = "abc".getBytes(StandardCharsets.UTF_8); +JSONObject object = new JSONObject(); +object.put("test", "42"); + +socket.emit("hello", 1, "2", bytes, object); +``` + +## Acknowledgements + +Events are great, but in some cases you may want a more classic request-response API. In Socket.IO, this feature is named acknowledgements. + +You can add a callback as the last argument of the `emit()`, and this callback will be called once the other side acknowledges the event: + +*Server* + +```js +io.on("connection", (socket) => { + socket.on("update item", (arg1, arg2, callback) => { + console.log(arg1); // 1 + console.log(arg2); // { name: "updated" } + callback({ + status: "ok" + }); + }); +}); +``` + +*Client* + +```java +socket.emit("update item", 1, new JSONObject(singletonMap("name", "updated")), new Ack() { + @Override + public void call(Object... args) { + JSONObject response = (JSONObject) args[0]; + System.out.println(response.getString("status")); // "ok" + } +}); +``` + diff --git a/src/site/markdown/initialization.md b/src/site/markdown/initialization.md new file mode 100644 index 00000000..efef638f --- /dev/null +++ b/src/site/markdown/initialization.md @@ -0,0 +1,316 @@ +# Initialization + +**Table of content** + + + +## Creation of a Socket instance + +```java +URI uri = URI.create("https://example.com"); +IO.Options options = IO.Options.builder() + // ... + .build(); + +Socket socket = IO.socket(uri, options); +``` + +Unlike the JS client (which can infer it from the `window.location` object), the URI is mandatory here. + +The [scheme](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier#Syntax) part of the URI is also mandatory. Both `ws://` and `http://` can be used interchangeably. + +```java +Socket socket = IO.socket("https://example.com"); // OK +Socket socket = IO.socket("wss://example.com"); // OK, similar to the example above +Socket socket = IO.socket("192.168.0.1:1234"); // NOT OK, missing the scheme part +``` + +The path represents the [Namespace](https://socket.io/docs/v3/namespaces/), and not the actual path (see [below](#path)) of the HTTP requests: + +```java +Socket socket = IO.socket(URI.create("https://example.com")); // the main namespace +Socket productSocket = IO.socket(URI.create("https://example.com/product")); // the "product" namespace +Socket orderSocket = IO.socket(URI.create("https://example.com/order")); // the "order" namespace +``` + +## Default values + +```java +IO.Options options = IO.Options.builder() + // IO factory options + .setForceNew(false) + .setMultiplex(true) + + // low-level engine options + .setTransports(new String[] { Polling.NAME, WebSocket.NAME }) + .setUpgrade(true) + .setRememberUpgrade(false) + .setPath("/socket.io/") + .setQuery(null) + .setExtraHeaders(null) + + // Manager options + .setReconnection(true) + .setReconnectionAttempts(Integer.MAX_VALUE) + .setReconnectionDelay(1_000) + .setReconnectionDelayMax(5_000) + .setRandomizationFactor(0.5) + .setTimeout(20_000) + + // Socket options + .setAuth(null) + .build(); +``` + +## Description + +### IO factory options + +These settings will be shared by all Socket instances attached to the same Manager. + +#### `forceNew` + +Default value: `false` + +Whether to create a new Manager instance. + +A Manager instance is in charge of the low-level connection to the server (established with HTTP long-polling or WebSocket). It handles the reconnection logic. + +A Socket instance is the interface which is used to sends events to — and receive events from — the server. It belongs to a given [namespace](https://socket.io/docs/v3/namespaces). + +A single Manager can be attached to several Socket instances. + +The following example will reuse the same Manager instance for the 3 Socket instances (one single WebSocket connection): + +```java +IO.Options options = IO.Options.builder() + .setForceNew(false) + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); // the main namespace +Socket productSocket = IO.socket(URI.create("https://example.com/product"), options); // the "product" namespace +Socket orderSocket = IO.socket(URI.create("https://example.com/order"), options); // the "order" namespace +``` + +The following example will create 3 different Manager instances (and thus 3 distinct WebSocket connections): + +```java +IO.Options options = IO.Options.builder() + .setForceNew(true) + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); // the main namespace +Socket productSocket = IO.socket(URI.create("https://example.com/product"), options); // the "product" namespace +Socket orderSocket = IO.socket(URI.create("https://example.com/order"), options); // the "order" namespace +``` + +#### `multiplex` + +Default value: `true` + +The opposite of `forceNew`: whether to reuse an existing Manager instance. + +### Low-level engine options + +#### `transports` + +Default value: `new String[] { Polling.NAME, WebSocket.NAME }` + +The low-level connection to the Socket.IO server can either be established with: + +- HTTP long-polling: successive HTTP requests (`POST` for writing, `GET` for reading) +- [WebSocket](https://en.wikipedia.org/wiki/WebSocket) + +The following example disables the HTTP long-polling transport: + +```java +IO.Options options = IO.Options.builder() + .setTransports(new String[] { WebSocket.NAME }) + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); +``` + +Note: in that case, sticky sessions are not required on the server side (more information [here](https://socket.io/docs/v3/using-multiple-nodes/)). + +#### `upgrade` + +Default value: `true` + +Whether the client should try to upgrade the transport from HTTP long-polling to something better. + +#### `rememberUpgrade` + +Default value: `false` + +If true and if the previous WebSocket connection to the server succeeded, the connection attempt will bypass the normal upgrade process and will initially try WebSocket. A connection attempt following a transport error will use the normal upgrade process. It is recommended you turn this on only when using SSL/TLS connections, or if you know that your network does not block websockets. + +#### `path` + +Default value: `/socket.io/` + +It is the name of the path that is captured on the server side. + +The server and the client values must match: + +*Server* + +```js +import { Server } from "socket.io"; + +const io = new Server(8080, { + path: "/my-custom-path/" +}); + +io.on("connection", (socket) => { + // ... +}); +``` + +*Client* + +```java +IO.Options options = IO.Options.builder() + .setPath("/my-custom-path/") + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); +``` + +Please note that this is different from the path in the URI, which represents the [Namespace](https://socket.io/docs/v3/namespaces/). + +Example: + +```java +IO.Options options = IO.Options.builder() + .setPath("/my-custom-path/") + .build(); + +Socket socket = IO.socket(URI.create("https://example.com/order"), options); +``` + +- the Socket instance is attached to the "order" Namespace +- the HTTP requests will look like: `GET https://example.com/my-custom-path/?EIO=4&transport=polling&t=ML4jUwU` + +#### `query` + +Default value: - + +Additional query parameters (then found in `socket.handshake.query` object on the server-side). + +Example: + +*Server* + +```js +io.on("connection", (socket) => { + console.log(socket.handshake.query); // prints { x: '42', EIO: '4', transport: 'polling' } +}); +``` + +*Client* + +```java +IO.Options options = IO.Options.builder() + .setQuery("x=42") + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); +``` + +Note: The `socket.handshake.query` object contains the query parameters that were sent during the Socket.IO handshake, it won't be updated for the duration of the current session, which means changing the `query` on the client-side will only be effective when the current session is closed and a new one is created: + +```java +socket.io().on(Manager.EVENT_RECONNECT_ATTEMPT, new Emitter.Listener() { + @Override + public void call(Object... args) { + options.query = "y=43"; + } +}); +``` + +#### `extraHeaders` + +Default value: - + +Additional headers (then found in `socket.handshake.headers` object on the server-side). + +Example: + +*Server* + +```js +io.on("connection", (socket) => { + console.log(socket.handshake.headers); // prints { accept: '*/*', authorization: 'bearer 1234', connection: 'Keep-Alive', 'accept-encoding': 'gzip', 'user-agent': 'okhttp/3.12.12' } +}); +``` + +*Client* + +```java +IO.Options options = IO.Options.builder() + .setExtraHeaders(singletonMap("authorization", singletonList("bearer 1234"))) + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); +``` + +Note: Similar to the `query` option above, the `socket.handshake.headers` object contains the headers that were sent during the Socket.IO handshake, it won't be updated for the duration of the current session, which means changing the `extraHeaders` on the client-side will only be effective when the current session is closed and a new one is created: + +```java +socket.io().on(Manager.EVENT_RECONNECT_ATTEMPT, new Emitter.Listener() { + @Override + public void call(Object... args) { + options.extraHeaders.put("authorization", singletonList("bearer 5678")); + } +}); +``` + +### Socket options + +These settings are specific to the given Socket instance. + +#### `auth` + +Default value: - + +Credentials that are sent when accessing a namespace (see also [here](https://socket.io/docs/v3/middlewares/#Sending-credentials)). + +Example: + +*Server* + +```js +io.on("connection", (socket) => { + console.log(socket.handshake.auth); // prints { token: 'abcd' } +}); +``` + +*Client* + +```java +IO.Options options = IO.Options.builder() + .setAuth(singletonMap("token", "abcd")) + .build(); + +Socket socket = IO.socket(URI.create("https://example.com"), options); +``` + +You can update the `auth` map when the access to the Namespace is denied: + +```java +socket.on(Socket.EVENT_CONNECT_ERROR, new Emitter.Listener() { + @Override + public void call(Object... args) { + options.auth.put("token", "efgh"); + socket.connect(); + } +}); +``` + +Or manually force the Socket instance to reconnect: + +```java +options.auth.put("token", "efgh"); +socket.disconnect().connect(); +``` diff --git a/src/site/markdown/installation.md b/src/site/markdown/installation.md index 8f9a2d9f..1eb05d80 100644 --- a/src/site/markdown/installation.md +++ b/src/site/markdown/installation.md @@ -3,8 +3,8 @@ | Client version | Socket.IO server | | -------------- | ---------------- | | 0.9.x | 1.x | -| 1.x | 2.x | -| 2.x | 3.x | +| 1.x | 2.x (or 3.1.x / 4.x with [`allowEIO3: true`](https://socket.io/docs/v4/server-initialization/#allowEIO3)) | +| 2.x | 3.x / 4.x | ## Installation The latest artifact is available on Maven Central. @@ -17,7 +17,7 @@ Add the following dependency to your `pom.xml`. io.socket socket.io-client - 2.0.0 + 2.0.1 ``` @@ -26,7 +26,7 @@ Add the following dependency to your `pom.xml`. Add it as a gradle dependency for Android Studio, in `build.gradle`: ```groovy -compile ('io.socket:socket.io-client:2.0.0') { +compile ('io.socket:socket.io-client:2.0.1') { // excluding org.json which is provided by Android exclude group: 'org.json', module: 'json' } diff --git a/src/site/markdown/listening_to_events.md b/src/site/markdown/listening_to_events.md new file mode 100644 index 00000000..6caf0a61 --- /dev/null +++ b/src/site/markdown/listening_to_events.md @@ -0,0 +1,71 @@ +# Listening to events + +See also: https://socket.io/docs/v3/listening-to-events/ + +**Table of content** + + + +There are several ways to handle events that are transmitted between the server and the client. + +## EventEmitter methods + +### socket.on(eventName, listener) + +Adds the *listener* function to the end of the listeners array for the event named *eventName*. + +```java +socket.on("details", new Emitter.Listener() { + @Override + public void call(Object... args) { + // ... + } +}); +``` + +### socket.once(eventName, listener) + +Adds a **one-time** *listener* function for the event named *eventName*. + +```java +socket.once("details", new Emitter.Listener() { + @Override + public void call(Object... args) { + // ... + } +}); +``` + +### socket.off(eventName, listener) + +Removes the specified *listener* from the listener array for the event named *eventName*. + +```java +Emitter.Listener listener = new Emitter.Listener() { + @Override + public void call(Object... args) { + calls.add("two"); + } +}; + +socket.on("details", listener); + +// and then later... +socket.off("details", listener); +``` + +### socket.off(eventName) + +Removes all listeners for the specific *eventName*. + +```java +socket.off("details"); +``` + +### socket.off() + +Removes all listeners (for any event). + +```java +socket.off(); +``` diff --git a/src/site/markdown/migrating_from_1_x.md b/src/site/markdown/migrating_from_1_x.md new file mode 100644 index 00000000..f13bebf3 --- /dev/null +++ b/src/site/markdown/migrating_from_1_x.md @@ -0,0 +1,177 @@ +# Migrating from 1.x + +The `2.0.0` release is the first release which is compatible with the Socket.IO v3 server. You can find more information about the v3 release here: https://socket.io/blog/socket-io-3-release/ + +Here is the compatibility table: + +| Java client version | Socket.IO server | +| -------------- | ---------------- | +| 0.9.x | 1.x | +| 1.x | 2.x (or 3.1.x / 4.x with [`allowEIO3: true`](https://socket.io/docs/v4/server-initialization/#allowEIO3)) | +| 2.x | 3.x / 4.x | + +**Important note:** due to the backward incompatible changes to the Socket.IO protocol, a 2.x Java client will not be able to reach a 2.x server, and vice-versa + +Since the Java client matches the Javascript client quite closely, most of the changes listed in the migration guide [here](https://socket.io/docs/v3/migrating-from-2-x-to-3-0) also apply to the Java client: + +- [A middleware error will now emit an Error object](#A_middleware_error_will_now_emit_an_Error_object) +- [The Socket `query` option is renamed to `auth`](#The_Socket_query_option_is_renamed_to_auth) +- [The Socket instance will no longer forward the events emitted by its Manager](#The_Socket_instance_will_no_longer_forward_the_events_emitted_by_its_Manager) +- [No more "pong" event](#No_more_.E2.80.9Cpong.E2.80.9D_event) + +Additional changes which are specific to the Java client: + +- [An `extraHeaders` option is now available](#An_extraHeaders_option_is_now_available) + +### A middleware error will now emit an Error object + +The `ERROR` event is renamed to `CONNECT_ERROR` and the object emitted is now a `JSONObject`: + +Before: + +```java +socket.on(Socket.EVENT_ERROR, new Emitter.Listener() { + @Override + public void call(Object... args) { + String error = (String) args[0]; + System.out.println(error); // not authorized + } +}); +``` + +After: + +```java +socket.on(Socket.EVENT_CONNECT_ERROR, new Emitter.Listener() { + @Override + public void call(Object... args) { + JSONObject error = (JSONObject) args[0]; + String message = error.getString("message"); + System.out.println(error); // not authorized + + JSONObject data = error.getJSONObject("data"); // additional details (optional) + } +}); +``` + + +### The Socket `query` option is renamed to `auth` + +In previous versions, the `query` option was used in two distinct places: + +- in the query parameters of the HTTP requests (`GET /socket.io/?EIO=3&abc=def`) +- in the Socket.IO handshake + +Which could lead to unexpected behaviors. + +New syntax: + +```java +IO.Options options = new IO.Options(); +options.query = singletonMap("abc", singletonList("def")); // included in the query parameters +options.auth = singletonMap("token", singletonList("1234")); // included in the Socket.IO handshake + +Socket socket = IO.socket("https://example.com", options); +``` + +### The Socket instance will no longer forward the events emitted by its Manager + +In previous versions, the Socket instance emitted the events related to the state of the underlying connection. This will not be the case anymore. + +You still have access to those events on the Manager instance (the `io()` method of the socket) : + +Before: + +```java +socket.on(Socket.EVENT_RECONNECT_ATTEMPT, new Emitter.Listener() { + @Override + public void call(Object... objects) { + // ... + } +}); +``` + +After: + +```java +socket.io().on(Manager.EVENT_RECONNECT_ATTEMPT, new Emitter.Listener() { + @Override + public void call(Object... objects) { + // ... + } +}); +``` + +Here is the updated list of events emitted by the Manager: + +| Name | Description | Previously (if different) | +| ---- | ----------- | ------------------------- | +| `Manager.EVENT_OPEN` | successful (re)connection | - | +| `Manager.EVENT_ERROR` | (re)connection failure or error after a successful connection | `Manager.EVENT_CONNECT_ERROR` & `Manager.EVENT_CONNECT_TIMEOUT` | +| `Manager.EVENT_CLOSE` | disconnection | - | +| `Manager.EVENT_RECONNECT_ATTEMPT` | reconnection attempt | `Manager.EVENT_RECONNECT_ATTEMPT` & `Manager.EVENT_RECONNECTING` (duplicate) | +| `Manager.EVENT_RECONNECT` | successful reconnection | - | +| `Manager.EVENT_RECONNECT_ERROR` | reconnection failure | - | +| `Manager.EVENT_RECONNECT_FAILED` | reconnection failure after all attempts | - | + +Here is the updated list of events emitted by the Socket: + +| Name | Description | Previously (if different) | +| ---- | ----------- | ------------------------- | +| `Socket.EVENT_CONNECT` | successful connection to a Namespace | - | +| `Socket.EVENT_CONNECT_ERROR` | connection failure | `Socket.EVENT_ERROR` | +| `Socket.EVENT_DISCONNECT` | disconnection | - | + + +And finally, here's the updated list of reserved events that you cannot use in your application: + +- `connect` (used on the client-side) +- `connect_error` (used on the client-side) +- `disconnect` (used on both sides) +- `disconnecting` (used on the server-side) +- `newListener` and `removeListener` (EventEmitter [reserved events](https://nodejs.org/api/events.html#events_event_newlistener)) + +```java +socket.emit("connect_error"); // will now throw an exception +``` + +### No more "pong" event + +In Socket.IO v2, you could listen to the `pong` event on the client-side, which included the duration of the last health check round-trip. + +Due to the reversal of the heartbeat mechanism (more information [here](https://socket.io/blog/engine-io-4-release/#Heartbeat-mechanism-reversal)), this event has been removed. + +Before: + +```java +socket.once(Socket.EVENT_PONG, new Emitter.Listener() { + @Override + public void call(Object... args) { + long latency = (long) args[0]; + // ... + } +}); +``` + +There is no similar API in the new release. + +### An `extraHeaders` option is now available + +This is a more straightforward way to provide headers that will be included in all HTTP requests. + +```java +IO.Options options = new IO.Options(); +options.extraHeaders = singletonMap("Authorization", singletonList("Bearer abcd")); + +Socket socket = IO.socket("https://example.com", options); +``` + +Or with the new builder syntax: + +```java +IO.Options options = IO.Options.builder() + .setExtraHeaders(singletonMap("Authorization", singletonList("Bearer abcd"))) + .build(); + +Socket socket = IO.socket("https://example.com", options); +``` diff --git a/src/site/markdown/socket_instance.md b/src/site/markdown/socket_instance.md new file mode 100644 index 00000000..26457164 --- /dev/null +++ b/src/site/markdown/socket_instance.md @@ -0,0 +1,158 @@ +# The Socket instance + +**Table of content** + + + +- [Javadoc](apidocs/index.html?io/socket/client/Socket.html) + +Besides [emitting](emitting_events.html) and [listening to](listening_to_events.html) events, the Socket instance has a few attributes that may be of use in your application: + +## Socket#id + +Each new connection is assigned a random 20-characters identifier. + +This identifier is synced with the value on the server-side. + +*Server* + +```js +io.on("connection", (socket) => { + console.log(socket.id); // x8WIv7-mJelg7on_ALbx +}); +``` + +*Client* + +```java +socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println(socket.id()); // x8WIv7-mJelg7on_ALbx + } +}); + +socket.on(Socket.EVENT_DISCONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println(socket.id()); // null + } +}); +``` + +## Socket#connected + +This attribute describes whether the socket is currently connected to the server. + +```java +socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println(socket.connected()); // true + } +}); + +socket.on(Socket.EVENT_DISCONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println(socket.connected()); // false + } +}); +``` + +## Lifecycle + +Lifecycle diagram + +## Events + +### `Socket.EVENT_CONNECT` + +This event is fired by the Socket instance upon connection / reconnection. + +```java +socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + // ... + } +}); +``` + +Please note that you shouldn't register event handlers in the `connect` handler itself, as a new handler will be registered every time the Socket reconnects: + +```java +// BAD +socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + socket.on("data", new Emitter.Listener() { + @Override + public void call(Object... args) { + // ... + } + }); + } +}); + +// GOOD +socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + // ... + } +}); + +socket.on("data", new Emitter.Listener() { + @Override + public void call(Object... args) { + // ... + } +}); +``` + +### `Socket.EVENT_CONNECT_ERROR` + +This event is fired when the server does not accept the connection (in a [middleware function](https://socket.io/docs/v3/middlewares/#Sending-credentials)). + +You need to manually reconnect. You might need to update the credentials: + +```java +socket.on(Socket.EVENT_CONNECT_ERROR, new Emitter.Listener() { + @Override + public void call(Object... args) { + options.auth.put("authorization", "bearer 1234"); + socket.connect(); + } +}); +``` + +### `Socket.EVENT_DISCONNECT` + +This event is fired upon disconnection. + +```java +socket.on(Socket.EVENT_DISCONNECT, new Emitter.Listener() { + @Override + public void call(Object... args) { + System.out.println(socket.id()); // null + } +}); +``` + +Here is the list of possible reasons: + +Reason | Description +------ | ----------- +`io server disconnect` | The server has forcefully disconnected the socket with [socket.disconnect()](https://socket.io/docs/v3/server-api/#socket-disconnect-close) +`io client disconnect` | The socket was manually disconnected using `socket.disconnect()` +`ping timeout` | The server did not respond in the `pingTimeout` range +`transport close` | The connection was closed (example: the user has lost connection, or the network was changed from WiFi to 4G) +`transport error` | The connection has encountered an error (example: the server was killed during a HTTP long-polling cycle) + +Note: those events, along with `disconnecting`, `newListener` and `removeListener`, are special events that shouldn't be used in your application: + +```js +// BAD, will throw an error +socket.emit("disconnect"); +``` diff --git a/src/site/resources/images/client_socket_events.png b/src/site/resources/images/client_socket_events.png new file mode 100644 index 00000000..c2ea34cc Binary files /dev/null and b/src/site/resources/images/client_socket_events.png differ diff --git a/src/site/site.xml b/src/site/site.xml index a006f9b4..3f81c927 100644 --- a/src/site/site.xml +++ b/src/site/site.xml @@ -8,6 +8,10 @@ 1.9 + + Socket.IO Java client + + @@ -21,7 +25,15 @@ - + + + + + + + + + diff --git a/src/test/java/io/socket/client/Connection.java b/src/test/java/io/socket/client/Connection.java index 9e7bf8c6..9f3a533e 100644 --- a/src/test/java/io/socket/client/Connection.java +++ b/src/test/java/io/socket/client/Connection.java @@ -6,7 +6,7 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; -import java.net.URISyntaxException; +import java.net.URI; import java.util.HashMap; import java.util.Map; import java.util.concurrent.*; @@ -77,24 +77,24 @@ public void stopServer() throws InterruptedException { serverService.awaitTermination(3000, TimeUnit.MILLISECONDS); } - Socket client() throws URISyntaxException { + Socket client() { return client(createOptions()); } - Socket client(String path) throws URISyntaxException { + Socket client(String path) { return client(path, createOptions()); } - Socket client(IO.Options opts) throws URISyntaxException { + Socket client(IO.Options opts) { return client(nsp(), opts); } - Socket client(String path, IO.Options opts) throws URISyntaxException { - return IO.socket(uri() + path, opts); + Socket client(String path, IO.Options opts) { + return IO.socket(URI.create(uri() + path), opts); } - String uri() { - return "http://localhost:" + PORT; + URI uri() { + return URI.create("http://localhost:" + PORT); } String nsp() { @@ -108,7 +108,7 @@ IO.Options createOptions() { } String[] createEnv() { - Map env = new HashMap(System.getenv()); + Map env = new HashMap<>(System.getenv()); env.put("DEBUG", "socket.io:*"); env.put("PORT", String.valueOf(PORT)); String[] _env = new String[env.size()]; diff --git a/src/test/java/io/socket/client/ConnectionTest.java b/src/test/java/io/socket/client/ConnectionTest.java index ee0c9237..aad9f4c4 100644 --- a/src/test/java/io/socket/client/ConnectionTest.java +++ b/src/test/java/io/socket/client/ConnectionTest.java @@ -29,8 +29,8 @@ public class ConnectionTest extends Connection { private Socket socket; @Test(timeout = TIMEOUT) - public void connectToLocalhost() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void connectToLocalhost() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -50,7 +50,7 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void startTwoConnectionsWithSamePath() throws URISyntaxException, InterruptedException { + public void startTwoConnectionsWithSamePath() throws InterruptedException { Socket s1 = client("/"); Socket s2 = client("/"); @@ -60,7 +60,7 @@ public void startTwoConnectionsWithSamePath() throws URISyntaxException, Interru } @Test(timeout = TIMEOUT) - public void startTwoConnectionsWithSamePathAndDifferentQuerystrings() throws URISyntaxException, InterruptedException { + public void startTwoConnectionsWithSamePathAndDifferentQuerystrings() throws InterruptedException { Socket s1 = client("/?woot"); Socket s2 = client("/"); @@ -70,8 +70,8 @@ public void startTwoConnectionsWithSamePathAndDifferentQuerystrings() throws URI } @Test(timeout = TIMEOUT) - public void workWithAcks() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void workWithAcks() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -111,8 +111,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void receiveDateWithAck() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void receiveDateWithAck() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -136,8 +136,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void sendBinaryAck() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void sendBinaryAck() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); final byte[] buf = "huehue".getBytes(Charset.forName("UTF-8")); socket = client(); @@ -168,8 +168,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void receiveBinaryDataWithAck() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void receiveBinaryDataWithAck() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); final byte[] buf = "huehue".getBytes(Charset.forName("UTF-8")); socket = client(); @@ -191,8 +191,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void workWithFalse() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void workWithFalse() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -212,8 +212,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void receiveUTF8MultibyteCharacters() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void receiveUTF8MultibyteCharacters() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); final String[] correct = new String[] { "てすと", "Я Б Г Д Ж Й", @@ -245,9 +245,9 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void connectToNamespaceAfterConnectionEstablished() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); - final Manager manager = new Manager(new URI(uri())); + public void connectToNamespaceAfterConnectionEstablished() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); + final Manager manager = new Manager(uri()); socket = manager.socket("/"); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -270,9 +270,9 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void connectToNamespaceAfterConnectionGetsClosed() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); - final Manager manager = new Manager(new URI(uri())); + public void connectToNamespaceAfterConnectionGetsClosed() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); + final Manager manager = new Manager(uri()); socket = manager.socket("/"); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -299,8 +299,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void reconnectByDefault() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void reconnectByDefault() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.io().on(Manager.EVENT_RECONNECT, new Emitter.Listener() { @Override @@ -320,8 +320,8 @@ public void run() { } @Test(timeout = TIMEOUT) - public void reconnectManually() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void reconnectManually() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.once(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -346,8 +346,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void reconnectAutomaticallyAfterReconnectingManually() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void reconnectAutomaticallyAfterReconnectingManually() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.once(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -378,14 +378,14 @@ public void run() { } @Test(timeout = 14000) - public void attemptReconnectsAfterAFailedReconnect() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void attemptReconnectsAfterAFailedReconnect() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.reconnection = true; opts.timeout = 0; opts.reconnectionAttempts = 2; opts.reconnectionDelay = 10; - final Manager manager = new Manager(new URI(uri()), opts); + final Manager manager = new Manager(uri(), opts); socket = manager.socket("/timeout"); manager.once(Manager.EVENT_RECONNECT_FAILED, new Emitter.Listener() { @Override @@ -415,15 +415,15 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void reconnectDelayShouldIncreaseEveryTime() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void reconnectDelayShouldIncreaseEveryTime() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.reconnection = true; opts.timeout = 0; opts.reconnectionAttempts = 3; opts.reconnectionDelay = 100; opts.randomizationFactor = 0.2; - final Manager manager = new Manager(new URI(uri()), opts); + final Manager manager = new Manager(uri(), opts); socket = manager.socket("/timeout"); final int[] reconnects = new int[] {0}; @@ -466,7 +466,7 @@ public void call(Object... args) { @Test(timeout = TIMEOUT) public void notReconnectWhenForceClosed() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.timeout = 0; opts.reconnectionDelay = 10; @@ -495,7 +495,7 @@ public void run() { @Test(timeout = TIMEOUT) public void stopReconnectingWhenForceClosed() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.timeout = 0; opts.reconnectionDelay = 10; @@ -524,8 +524,8 @@ public void run() { } @Test(timeout = TIMEOUT) - public void reconnectAfterStoppingReconnection() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void reconnectAfterStoppingReconnection() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.forceNew = true; opts.timeout = 0; @@ -550,9 +550,9 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void stopReconnectingOnASocketAndKeepToReconnectOnAnother() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); - final Manager manager = new Manager(new URI(uri())); + public void stopReconnectingOnASocketAndKeepToReconnectOnAnother() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); + final Manager manager = new Manager(uri()); final Socket socket1 = manager.socket("/"); final Socket socket2 = manager.socket("/asd"); @@ -596,10 +596,10 @@ public void run() { } @Test(timeout = TIMEOUT) - public void connectWhileDisconnectingAnotherSocket() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void connectWhileDisconnectingAnotherSocket() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); - final Manager manager = new Manager(new URI(uri())); + final Manager manager = new Manager(uri()); final Socket socket1 = manager.socket("/foo"); socket1.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -623,13 +623,13 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void tryToReconnectTwiceAndFailWithIncorrectAddress() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void tryToReconnectTwiceAndFailWithIncorrectAddress() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = new IO.Options(); opts.reconnection = true; opts.reconnectionAttempts = 2; opts.reconnectionDelay = 10; - final Manager manager = new Manager(new URI("http://localhost:3940"), opts); + final Manager manager = new Manager(URI.create("http://localhost:3940"), opts); socket = manager.socket("/asd"); final int[] reconnects = new int[] {0}; Emitter.Listener cb = new Emitter.Listener() { @@ -655,14 +655,14 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void tryToReconnectTwiceAndFailWithImmediateTimeout() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void tryToReconnectTwiceAndFailWithImmediateTimeout() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = new IO.Options(); opts.reconnection = true; opts.timeout = 0; opts.reconnectionAttempts = 2; opts.reconnectionDelay = 10; - final Manager manager = new Manager(new URI(uri()), opts); + final Manager manager = new Manager(uri(), opts); final int[] reconnects = new int[] {0}; Emitter.Listener reconnectCb = new Emitter.Listener() { @@ -688,11 +688,11 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void notTryToReconnectWithIncorrectPortWhenReconnectionDisabled() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void notTryToReconnectWithIncorrectPortWhenReconnectionDisabled() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = new IO.Options(); opts.reconnection = false; - final Manager manager = new Manager(new URI("http://localhost:9823"), opts); + final Manager manager = new Manager(URI.create("http://localhost:9823"), opts); Emitter.Listener cb = new Emitter.Listener() { @Override public void call(Object... objects) { @@ -722,15 +722,15 @@ public void run() { } @Test(timeout = TIMEOUT) - public void fireReconnectEventsOnSocket() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void fireReconnectEventsOnSocket() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); Manager.Options opts = new Manager.Options(); opts.reconnection = true; opts.timeout = 0; opts.reconnectionAttempts = 2; opts.reconnectionDelay = 10; - final Manager manager = new Manager(new URI(uri()), opts); + final Manager manager = new Manager(uri(), opts); socket = manager.socket("/timeout_socket"); final int[] reconnects = new int[] {0}; @@ -757,15 +757,15 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void fireReconnectingWithAttemptsNumberWhenReconnectingTwice() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void fireReconnectingWithAttemptsNumberWhenReconnectingTwice() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); Manager.Options opts = new Manager.Options(); opts.reconnection = true; opts.timeout = 0; opts.reconnectionAttempts = 2; opts.reconnectionDelay = 10; - final Manager manager = new Manager(new URI(uri()), opts); + final Manager manager = new Manager(uri(), opts); socket = manager.socket("/timeout_socket"); final int[] reconnects = new int[] {0}; @@ -792,8 +792,8 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void emitDateAsString() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void emitDateAsString() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -813,8 +813,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void emitDateInObject() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void emitDateInObject() throws InterruptedException, JSONException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -843,8 +843,8 @@ public void call(Object... args) { @Test(timeout = TIMEOUT) - public void sendAndGetBinaryData() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void sendAndGetBinaryData() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); final byte[] buf = "asdfasdf".getBytes(Charset.forName("UTF-8")); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -865,8 +865,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void sendBinaryDataMixedWithJson() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void sendBinaryDataMixedWithJson() throws InterruptedException, JSONException { + final BlockingQueue values = new LinkedBlockingQueue<>(); final byte[] buf = "howdy".getBytes(Charset.forName("UTF-8")); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -899,7 +899,7 @@ public void call(Object... args) { @Test(timeout = TIMEOUT) public void sendEventsWithByteArraysInTheCorrectOrder() throws Exception { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); final byte[] buf = "abuff1".getBytes(Charset.forName("UTF-8")); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { diff --git a/src/test/java/io/socket/client/SSLConnectionTest.java b/src/test/java/io/socket/client/SSLConnectionTest.java index 26ad1b10..6f475fb3 100644 --- a/src/test/java/io/socket/client/SSLConnectionTest.java +++ b/src/test/java/io/socket/client/SSLConnectionTest.java @@ -16,6 +16,7 @@ import java.io.File; import java.io.FileInputStream; import java.io.IOException; +import java.net.URI; import java.security.GeneralSecurityException; import java.security.KeyStore; import java.util.concurrent.BlockingQueue; @@ -39,8 +40,8 @@ public class SSLConnectionTest extends Connection { } @Override - String uri() { - return "https://localhost:" + PORT; + URI uri() { + return URI.create("https://localhost:" + PORT); } @Override @@ -88,7 +89,7 @@ public void tearDown() { @Test(timeout = TIMEOUT) public void connect() throws Exception { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.callFactory = sOkHttpClient; opts.webSocketFactory = sOkHttpClient; @@ -112,7 +113,7 @@ public void call(Object... args) { @Test(timeout = TIMEOUT) public void defaultSSLContext() throws Exception { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.setDefaultOkHttpWebSocketFactory(sOkHttpClient); IO.setDefaultOkHttpCallFactory(sOkHttpClient); socket = client(); diff --git a/src/test/java/io/socket/client/ServerConnectionTest.java b/src/test/java/io/socket/client/ServerConnectionTest.java index 6c421a1b..c2e9354e 100644 --- a/src/test/java/io/socket/client/ServerConnectionTest.java +++ b/src/test/java/io/socket/client/ServerConnectionTest.java @@ -9,7 +9,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import java.net.URISyntaxException; import java.util.Arrays; import java.util.List; import java.util.Map; @@ -26,8 +25,8 @@ public class ServerConnectionTest extends Connection { private Socket socket2; @Test(timeout = TIMEOUT) - public void openAndClose() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void openAndClose() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -51,8 +50,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void message() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void message() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -75,7 +74,7 @@ public void call(Object... args) { @Test(timeout = TIMEOUT) public void event() throws Exception { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); final JSONObject obj = new JSONObject(); obj.put("foo", 1); @@ -104,7 +103,7 @@ public void call(Object... args) { @Test(timeout = TIMEOUT) public void ack() throws Exception { - final BlockingQueue values = new LinkedBlockingQueue(); + final BlockingQueue values = new LinkedBlockingQueue<>(); final JSONObject obj = new JSONObject(); obj.put("foo", 1); @@ -131,8 +130,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void ackWithoutArgs() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void ackWithoutArgs() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -153,8 +152,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void ackWithoutArgsFromClient() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void ackWithoutArgsFromClient() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -188,8 +187,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void closeEngineConnection() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void closeEngineConnection() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -209,18 +208,14 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void broadcast() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void broadcast() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override public void call(Object... objects) { - try { - socket2 = client(); - } catch (URISyntaxException e) { - throw new RuntimeException(e); - } + socket2 = client(); socket2.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -246,8 +241,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void room() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void room() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @@ -270,8 +265,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void pollingHeaders() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void pollingHeaders() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.transports = new String[] {Polling.NAME}; @@ -305,8 +300,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void websocketHandshakeHeaders() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void websocketHandshakeHeaders() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = createOptions(); opts.transports = new String[] {WebSocket.NAME}; @@ -340,8 +335,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void disconnectFromServer() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void disconnectFromServer() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { diff --git a/src/test/java/io/socket/client/SocketTest.java b/src/test/java/io/socket/client/SocketTest.java index 5851ff77..7cc76fd5 100644 --- a/src/test/java/io/socket/client/SocketTest.java +++ b/src/test/java/io/socket/client/SocketTest.java @@ -8,7 +8,6 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import java.net.URISyntaxException; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.BlockingQueue; @@ -26,8 +25,8 @@ public class SocketTest extends Connection { private Socket socket; @Test(timeout = TIMEOUT) - public void shouldHaveAnAccessibleSocketIdEqualToServerSideSocketId() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldHaveAnAccessibleSocketIdEqualToServerSideSocketId() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -45,8 +44,8 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void shouldHaveAnAccessibleSocketIdEqualToServerSideSocketIdOnCustomNamespace() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldHaveAnAccessibleSocketIdEqualToServerSideSocketIdOnCustomNamespace() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client("/foo"); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -64,8 +63,8 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void clearsSocketIdUponDisconnection() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void clearsSocketIdUponDisconnection() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -87,8 +86,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void doesNotFireConnectErrorIfWeForceDisconnectInOpeningState() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void doesNotFireConnectErrorIfWeForceDisconnectInOpeningState() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = new IO.Options(); opts.timeout = 100; socket = client(opts); @@ -114,8 +113,8 @@ public void run() { } @Test(timeout = TIMEOUT) - public void shouldChangeSocketIdUponReconnection() throws URISyntaxException, InterruptedException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldChangeSocketIdUponReconnection() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client(); socket.once(Socket.EVENT_CONNECT, new Emitter.Listener() { @Override @@ -155,8 +154,8 @@ public void call(Object... objects) { } @Test(timeout = TIMEOUT) - public void shouldAcceptAQueryStringOnDefaultNamespace() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldAcceptAQueryStringOnDefaultNamespace() throws InterruptedException, JSONException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client("/?c=d"); socket.emit("getHandshake", new Ack() { @@ -176,8 +175,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void shouldAcceptAQueryString() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldAcceptAQueryString() throws InterruptedException, JSONException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client("/abc?b=c&d=e"); socket.on("handshake", new Emitter.Listener() { @@ -199,8 +198,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void shouldAcceptAnAuthOption() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldAcceptAnAuthOption() throws InterruptedException, JSONException { + final BlockingQueue values = new LinkedBlockingQueue<>(); IO.Options opts = new IO.Options(); opts.auth = singletonMap("token", "abcd"); @@ -223,8 +222,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void shouldFireAnErrorEventOnMiddlewareFailure() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldFireAnErrorEventOnMiddlewareFailure() throws InterruptedException, JSONException { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client("/no"); socket.on(Socket.EVENT_CONNECT_ERROR, new Emitter.Listener() { @@ -245,8 +244,8 @@ public void call(Object... args) { } @Test(timeout = TIMEOUT) - public void shouldThrowOnReservedEvent() throws URISyntaxException, InterruptedException, JSONException { - final BlockingQueue values = new LinkedBlockingQueue(); + public void shouldThrowOnReservedEvent() { + final BlockingQueue values = new LinkedBlockingQueue<>(); socket = client("/no"); try { @@ -258,4 +257,34 @@ public void shouldThrowOnReservedEvent() throws URISyntaxException, InterruptedE socket.disconnect(); } + + @Test(timeout = TIMEOUT) + public void shouldEmitEventsInOrder() throws InterruptedException { + final BlockingQueue values = new LinkedBlockingQueue<>(); + + socket = client(); + + socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() { + @Override + public void call(Object... objects) { + socket.emit("ack", "second", new Ack() { + @Override + public void call(Object... args) { + values.offer((String) args[0]); + } + }); + } + }); + + socket.emit("ack", "first", new Ack() { + @Override + public void call(Object... args) { + values.offer((String) args[0]); + } + }); + + socket.connect(); + assertThat(values.take(), is("first")); + assertThat(values.take(), is("second")); + } } diff --git a/src/test/java/io/socket/client/UrlTest.java b/src/test/java/io/socket/client/UrlTest.java index fbcf42de..47a1a0c1 100644 --- a/src/test/java/io/socket/client/UrlTest.java +++ b/src/test/java/io/socket/client/UrlTest.java @@ -4,9 +4,7 @@ import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -import java.net.MalformedURLException; -import java.net.URISyntaxException; -import java.net.URL; +import java.net.URI; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.not; @@ -15,58 +13,85 @@ @RunWith(JUnit4.class) public class UrlTest { + private URI parse(String uri) { + return Url.parse(URI.create(uri)).uri; + } + + private String extractId(String uri) { + return Url.parse(URI.create(uri)).id; + } + @Test - public void parse() throws URISyntaxException { - assertThat(Url.parse("http://username:password@host:8080/directory/file?query#ref").toString(), + public void parse() { + assertThat(parse("http://username:password@host:8080/directory/file?query#ref").toString(), is("http://username:password@host:8080/directory/file?query#ref")); } @Test - public void parseRelativePath() throws URISyntaxException { - URL url = Url.parse("https://woot.com/test"); - assertThat(url.getProtocol(), is("https")); - assertThat(url.getHost(), is("woot.com")); - assertThat(url.getPath(), is("/test")); + public void parseRelativePath() { + URI uri = parse("https://woot.com/test"); + assertThat(uri.getScheme(), is("https")); + assertThat(uri.getHost(), is("woot.com")); + assertThat(uri.getPath(), is("/test")); } @Test - public void parseNoProtocol() throws URISyntaxException { - URL url = Url.parse("//localhost:3000"); - assertThat(url.getProtocol(), is("https")); - assertThat(url.getHost(), is("localhost")); - assertThat(url.getPort(), is(3000)); + public void parseNoProtocol() { + URI uri = parse("//localhost:3000"); + assertThat(uri.getScheme(), is("https")); + assertThat(uri.getHost(), is("localhost")); + assertThat(uri.getPort(), is(3000)); } @Test - public void parseNamespace() throws URISyntaxException { - assertThat(Url.parse("http://woot.com/woot").getPath(), is("/woot")); - assertThat(Url.parse("http://google.com").getPath(), is("/")); - assertThat(Url.parse("http://google.com/").getPath(), is("/")); + public void parseNamespace() { + assertThat(parse("http://woot.com/woot").getPath(), is("/woot")); + assertThat(parse("http://google.com").getPath(), is("/")); + assertThat(parse("http://google.com/").getPath(), is("/")); } @Test - public void parseDefaultPort() throws URISyntaxException { - assertThat(Url.parse("http://google.com/").toString(), is("http://google.com:80/")); - assertThat(Url.parse("https://google.com/").toString(), is("https://google.com:443/")); + public void parseDefaultPort() { + assertThat(parse("http://google.com/").toString(), is("http://google.com:80/")); + assertThat(parse("https://google.com/").toString(), is("https://google.com:443/")); } @Test - public void extractId() throws MalformedURLException { - String id1 = Url.extractId("http://google.com:80/"); - String id2 = Url.extractId("http://google.com/"); - String id3 = Url.extractId("https://google.com/"); + public void testWsProtocol() { + URI uri = parse("ws://woot.com/test"); + assertThat(uri.getScheme(), is("ws")); + assertThat(uri.getHost(), is("woot.com")); + assertThat(uri.getPort(), is(80)); + assertThat(uri.getPath(), is("/test")); + } + + @Test + public void testWssProtocol() { + URI uri = parse("wss://woot.com/test"); + assertThat(uri.getScheme(), is("wss")); + assertThat(uri.getHost(), is("woot.com")); + assertThat(uri.getPort(), is(443)); + assertThat(uri.getPath(), is("/test")); + } + + @Test + public void extractId() { + String id1 = extractId("http://google.com:80/"); + String id2 = extractId("http://google.com/"); + String id3 = extractId("https://google.com/"); assertThat(id1, is(id2)); assertThat(id1, is(not(id3))); assertThat(id2, is(not(id3))); } @Test - public void ipv6() throws URISyntaxException, MalformedURLException { + public void ipv6() { String url = "http://[::1]"; - URL parsed = Url.parse(url); - assertThat(parsed.getProtocol(), is("http")); + URI parsed = parse(url); + assertThat(parsed.getScheme(), is("http")); assertThat(parsed.getHost(), is("[::1]")); assertThat(parsed.getPort(), is(80)); - assertThat(Url.extractId(url), is("http://[::1]:80")); + assertThat(extractId(url), is("http://[::1]:80")); } + } diff --git a/src/test/java/io/socket/parser/ByteArrayTest.java b/src/test/java/io/socket/parser/ByteArrayTest.java index a358c15c..d48547cf 100644 --- a/src/test/java/io/socket/parser/ByteArrayTest.java +++ b/src/test/java/io/socket/parser/ByteArrayTest.java @@ -1,15 +1,15 @@ package io.socket.parser; -import io.socket.emitter.Emitter; import org.json.JSONArray; import org.json.JSONException; -import org.json.JSONObject; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; +import static java.util.Arrays.asList; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; @@ -19,9 +19,9 @@ public class ByteArrayTest { private static Parser.Encoder encoder = new IOParser.Encoder(); @Test - public void encodeByteArray() { - Packet packet = new Packet(Parser.BINARY_EVENT); - packet.data = "abc".getBytes(Charset.forName("UTF-8")); + public void encodeByteArray() throws JSONException { + Packet packet = new Packet<>(Parser.BINARY_EVENT); + packet.data = new JSONArray(asList("abc", "abc".getBytes(StandardCharsets.UTF_8))); packet.id = 23; packet.nsp = "/cool"; Helpers.testBin(packet); @@ -29,8 +29,8 @@ public void encodeByteArray() { @Test public void encodeByteArray2() { - Packet packet = new Packet(Parser.BINARY_EVENT); - packet.data = new byte[2]; + Packet packet = new Packet<>(Parser.BINARY_EVENT); + packet.data = new JSONArray(asList("2", new byte[] { 0, 1 })); packet.id = 0; packet.nsp = "/"; Helpers.testBin(packet); @@ -38,11 +38,11 @@ public void encodeByteArray2() { @Test public void encodeByteArrayDeepInJson() throws JSONException { - JSONObject data = new JSONObject("{a: \"hi\", b: {}, c: {a: \"bye\", b: {}}}"); - data.getJSONObject("b").put("why", new byte[3]); - data.getJSONObject("c").getJSONObject("b").put("a", new byte[6]); + JSONArray data = new JSONArray("[{a: \"hi\", b: {}, c: {a: \"bye\", b: {}}}]"); + data.getJSONObject(0).getJSONObject("b").put("why", new byte[3]); + data.getJSONObject(0).getJSONObject("c").getJSONObject("b").put("a", new byte[6]); - Packet packet = new Packet(Parser.BINARY_EVENT); + Packet packet = new Packet<>(Parser.BINARY_EVENT); packet.data = data; packet.id = 999; packet.nsp = "/deep"; @@ -51,10 +51,10 @@ public void encodeByteArrayDeepInJson() throws JSONException { @Test public void encodeDeepBinaryJSONWithNullValue() throws JSONException { - JSONObject data = new JSONObject("{a: \"b\", c: 4, e: {g: null}, h: null}"); - data.put("h", new byte[9]); + JSONArray data = new JSONArray("[{a: \"b\", c: 4, e: {g: null}, h: null}]"); + data.getJSONObject(0).put("h", new byte[9]); - Packet packet = new Packet(Parser.BINARY_EVENT); + Packet packet = new Packet<>(Parser.BINARY_EVENT); packet.data = data; packet.nsp = "/"; packet.id = 600; @@ -66,7 +66,7 @@ public void encodeBinaryAckWithByteArray() throws JSONException { JSONArray data = new JSONArray("[a, null, {}]"); data.put(1, "xxx".getBytes(Charset.forName("UTF-8"))); - Packet packet = new Packet(Parser.BINARY_ACK); + Packet packet = new Packet<>(Parser.BINARY_ACK); packet.data = data; packet.id = 127; packet.nsp = "/back"; @@ -79,7 +79,7 @@ public void cleanItselfUpOnClose() { data.put(new byte[2]); data.put(new byte[3]); - Packet packet = new Packet(Parser.BINARY_EVENT); + Packet packet = new Packet<>(Parser.BINARY_EVENT); packet.data = data; packet.id = 0; packet.nsp = "/"; diff --git a/src/test/java/io/socket/parser/ParserTest.java b/src/test/java/io/socket/parser/ParserTest.java index c13005c4..17d48863 100644 --- a/src/test/java/io/socket/parser/ParserTest.java +++ b/src/test/java/io/socket/parser/ParserTest.java @@ -27,12 +27,12 @@ public void encodeDisconnection() { @Test public void encodeEvent() throws JSONException { - Packet packet1 = new Packet(Parser.EVENT); + Packet packet1 = new Packet<>(Parser.EVENT); packet1.data = new JSONArray("[\"a\", 1, {}]"); packet1.nsp = "/"; Helpers.test(packet1); - Packet packet2 = new Packet(Parser.EVENT); + Packet packet2 = new Packet<>(Parser.EVENT); packet2.data = new JSONArray("[\"a\", 1, {}]"); packet2.nsp = "/test"; Helpers.test(packet2); @@ -40,7 +40,7 @@ public void encodeEvent() throws JSONException { @Test public void encodeAck() throws JSONException { - Packet packet = new Packet(Parser.ACK); + Packet packet = new Packet<>(Parser.ACK); packet.data = new JSONArray("[\"a\", 1, {}]"); packet.id = 123; packet.nsp = "/"; @@ -63,5 +63,8 @@ public void decodeInError() throws JSONException { Helpers.testDecodeError(Parser.EVENT + "2sd"); // event with invalid json data Helpers.testDecodeError(Parser.EVENT + "2[\"a\",1,{asdf}]"); + Helpers.testDecodeError(Parser.EVENT + "2{}"); + Helpers.testDecodeError(Parser.EVENT + "2[]"); + Helpers.testDecodeError(Parser.EVENT + "2[null]"); } } diff --git a/src/test/java/io/socket/util/Optional.java b/src/test/java/io/socket/util/Optional.java index aadc6036..f4868395 100644 --- a/src/test/java/io/socket/util/Optional.java +++ b/src/test/java/io/socket/util/Optional.java @@ -12,11 +12,11 @@ public static Optional of(T value) { if (value == null) { throw new NullPointerException(); } - return new Optional(value); + return new Optional<>(value); } public static Optional ofNullable(T value) { - return new Optional(value); + return new Optional<>(value); } public static Optional empty() {