Add WebTransport integration to Socket.IO Java client

pom.xml

@@ -107,8 +107,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.5.1</version>
         <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
+          <source>17</source>
+          <target>17</target>
           <compilerArgs>
             <arg>-Xlint:unchecked</arg>
           </compilerArgs>

src/site/markdown/initialization.md

@@ -42,12 +42,18 @@ IO.Options options = IO.Options.builder()
     .setMultiplex(true)
 
     // low-level engine options
-    .setTransports(new String[] { Polling.NAME, WebSocket.NAME })
+    .setTransports(new String[] { Polling.NAME, WebSocket.NAME, WebTransport.NAME })
     .setUpgrade(true)
     .setRememberUpgrade(false)
     .setPath("/socket.io/")
     .setQuery(null)
     .setExtraHeaders(null)
+
+    // WebTransport options
+    .setWebTransportEnabled(true)
+    .setWebTransportConnectTimeout(30000)
+    .setWebTransportIdleTimeout(60000)
+    .setWebTransportTrustAllCertificates(false)
 
     // Manager options
     .setReconnection(true)
@@ -114,12 +120,13 @@ The opposite of `forceNew`: whether to reuse an existing Manager instance.
 
 #### `transports`
 
-Default value: `new String[] { Polling.NAME, WebSocket.NAME }`
+Default value: `new String[] { Polling.NAME, WebSocket.NAME, WebTransport.NAME }`
 
-The low-level connection to the Socket.IO server can either be established with:
+The low-level connection to the Socket.IO server can be established with:
 
 - HTTP long-polling: successive HTTP requests (`POST` for writing, `GET` for reading)
 - [WebSocket](https://en.wikipedia.org/wiki/WebSocket)
+- [WebTransport](https://www.w3.org/TR/webtransport/): HTTP/3-based transport with QUIC protocol for improved performance
 
 The following example disables the HTTP long-polling transport:
 
@@ -133,6 +140,17 @@ 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/v4/using-multiple-nodes/)).
 
+The following example enables only WebTransport:
+
+```java
+IO.Options options = IO.Options.builder()
+        .setTransports(new String[] { WebTransport.NAME })
+        .setWebTransportEnabled(true)
+        .build();
+
+Socket socket = IO.socket(URI.create("https://example.com"), options);
+```
+
 #### `upgrade`
 
 Default value: `true`
@@ -190,7 +208,94 @@ 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`
+
+### WebTransport support
+
+WebTransport is a modern transport protocol based on HTTP/3 and QUIC that provides improved performance, reduced latency, and better handling of network conditions compared to traditional WebSocket connections.
+
+WebTransport is configured exactly like other transports - simply include it in the `transports` array:
+
+```java
+import io.socket.engineio.client.transports.WebTransport;
+import io.socket.engineio.client.transports.WebSocket;
+import io.socket.engineio.client.transports.Polling;
+
+IO.Options options = IO.Options.builder()
+        .setTransports(new String[] { 
+            WebTransport.NAME,  // Try WebTransport first
+            WebSocket.NAME,     // Fall back to WebSocket
+            Polling.NAME        // Final fallback to Polling
+        })
+        .build();
+
+Socket socket = IO.socket(URI.create("https://example.com"), options);
+```
+
+#### Transport-specific options (advanced)
+
+For advanced WebTransport configuration, you can provide transport-specific options:
+
+```java
+import io.socket.engineio.client.Transport;
+
+// Create WebTransport-specific options
+Transport.Options webTransportOptions = new Transport.Options();
+webTransportOptions.hostname = "127.0.0.1";  // Override hostname if needed
+webTransportOptions.port = 3000;             // Override port if needed
+webTransportOptions.secure = true;           // WebTransport requires HTTPS
+webTransportOptions.path = "/socket.io/";    // Socket.IO path
+
+// Apply transport-specific options
+IO.Options options = IO.Options.builder()
+        .setTransports(new String[] { WebTransport.NAME, WebSocket.NAME, Polling.NAME })
+        .build();
+
+// Add transport-specific options
+if (options.transportOptions == null) {
+    options.transportOptions = new HashMap<>();
+}
+options.transportOptions.put("webtransport", webTransportOptions);
+
+Socket socket = IO.socket(URI.create("https://example.com"), options);
+```
+
+#### SSL configuration for self-signed certificates (development only)
+
+For development with self-signed certificates, configure the OkHttp client:
+
+```java
+import okhttp3.OkHttpClient;
+import javax.net.ssl.X509TrustManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+
+// Create trust-all SSL configuration (DEVELOPMENT ONLY!)
+X509TrustManager trustAllCerts = new X509TrustManager() {
+    public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; }
+    public void checkClientTrusted(X509Certificate[] certs, String authType) {}
+    public void checkServerTrusted(X509Certificate[] certs, String authType) {}
+};
+
+SSLContext sslContext = SSLContext.getInstance("TLS");
+sslContext.init(null, new TrustManager[]{trustAllCerts}, new SecureRandom());
+
+OkHttpClient okHttpClient = new OkHttpClient.Builder()
+        .sslSocketFactory(sslContext.getSocketFactory(), trustAllCerts)
+        .hostnameVerifier((hostname, session) -> true)
+        .build();
+
+IO.Options options = IO.Options.builder()
+        .setTransports(new String[] { WebTransport.NAME, WebSocket.NAME, Polling.NAME })
+        .setCallFactory(okHttpClient)      // For HTTP requests
+        .setWebSocketFactory(okHttpClient) // For WebSocket connections
+        .build();
+```
+
+**Important notes:**
+- WebTransport requires HTTPS connections and HTTP/3 support on both client and server sides
+- The client will automatically fall back to WebSocket or Polling if WebTransport fails
+- WebTransport uses the same configuration approach as other transports - no special setup required
+- Only use SSL certificate bypassing in development environments
 
 #### `query`