Add smack-websocket-java11

This also lifts a bunch of logic from smack-websocket-okhttp into
smack-websocket. Furthermore, the following subprojects require now
Java 11:
- smack-integration-test
- smack-omemo-signal-integration-test
- smack-repl
- smack-websocket-java11

Related tracking issue: SMACK-835

.github/workflows/ci.yml

@@ -12,7 +12,8 @@ jobs:
     runs-on: ubuntu-20.04
     strategy:
       matrix:
-        java: [ 1.8, 11 ]
+        java:
+          - 11
 
     steps:
       - name: Checkout

build.gradle

@@ -20,6 +20,29 @@ plugins {
 
 apply plugin: 'org.kordamp.gradle.markdown'
 
+ext {
+	java11Projects = [
+		':smack-integration-test',
+		':smack-omemo-signal-integration-test',
+		':smack-repl',
+		':smack-websocket-java11',
+	].collect { project(it) }
+	java11Projects += getRootProject()
+	java8Projects = allprojects - java11Projects
+}
+
+configure (java8Projects) {
+	ext {
+		javaCompatilibity = JavaVersion.VERSION_1_8
+	}
+}
+
+configure (java11Projects) {
+	ext {
+		javaCompatilibity = JavaVersion.VERSION_11
+	}
+}
+
 allprojects {
 	apply plugin: 'java-library'
 	apply plugin: 'java-test-fixtures'
@@ -136,7 +159,6 @@ allprojects {
 			// Default to true
 			useSonatype = true
 		}
-		javaCompatilibity = JavaVersion.VERSION_1_8
 		javaMajor = javaCompatilibity.getMajorVersion()
 	}
 	group = 'org.igniterealtime.smack'
@@ -338,7 +360,7 @@ task javadocAll(type: Javadoc) {
 		linkSource = true
 		use = true
 		links = [
-		"https://docs.oracle.com/javase/${javaMajor}/docs/api/",
+		"https://docs.oracle.com/en/java/javase/${javaMajor}/docs/api/",
 		"https://jxmpp.org/releases/${staticJxmppVersion}/javadoc/",
 		"https://minidns.org/releases/${staticMiniDnsVersion}/javadoc/",
 		] as String[]

settings.gradle

@@ -32,6 +32,7 @@ include 'smack-core',
 		'smack-openpgp',
 		'smack-websocket',
 		'smack-websocket-okhttp',
+		'smack-websocket-java11',
 		'smack-xmlparser',
 		'smack-xmlparser-stax',
 		'smack-xmlparser-xpp3'

smack-core/src/main/java/org/jivesoftware/smack/c2s/XmppClientToServerTransport.java

@@ -54,8 +54,6 @@ public abstract class XmppClientToServerTransport {
 
     public abstract SSLSession getSslSession();
 
-    public abstract boolean isConnected();
-
     public boolean isTransportSecured() {
         return getSslSession() != null;
     }

smack-core/src/main/java/org/jivesoftware/smack/util/rce/RemoteConnectionEndpoint.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2020 Florian Schmaus
+ * Copyright 2020-2021 Florian Schmaus
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,6 +32,10 @@ public interface RemoteConnectionEndpoint {
 
     String getDescription();
 
+    default String getRawString() {
+        return toString();
+    }
+
     class InetSocketAddressCoupling<RCE extends RemoteConnectionEndpoint> {
         private final RCE connectionEndpoint;
         private final InetSocketAddress inetSocketAddress;

smack-integration-test/build.gradle

@@ -9,6 +9,7 @@ applicationDefaultJvmArgs = ["-enableassertions"]
 dependencies {
 	api project(':smack-java8-full')
 	api project(':smack-resolver-dnsjava')
+	implementation project(':smack-websocket-java11')
 	implementation "com.google.guava:guava:${guavaVersion}"
 	compile 'org.reflections:reflections:0.9.12'
 	compile 'eu.geekplace.javapinning:java-pinning-java7:1.1.0-alpha1'

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/AbstractSmackSpecificLowLevelIntegrationTest.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2018-2020 Florian Schmaus
+ * Copyright 2018-2021 Florian Schmaus
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,15 +30,12 @@ public abstract class AbstractSmackSpecificLowLevelIntegrationTest<C extends Abs
 
     private final SmackIntegrationTestEnvironment environment;
 
-    protected final Class<C> connectionClass;
-
     private final XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor;
 
     public AbstractSmackSpecificLowLevelIntegrationTest(SmackIntegrationTestEnvironment environment,
             Class<C> connectionClass) {
         super(environment);
         this.environment = environment;
-        this.connectionClass = connectionClass;
 
         connectionDescriptor = environment.connectionManager.getConnectionDescriptorFor(connectionClass);
         if (connectionDescriptor == null) {
@@ -46,8 +43,8 @@ public abstract class AbstractSmackSpecificLowLevelIntegrationTest<C extends Abs
         }
     }
 
-    public Class<C> getConnectionClass() {
+    public XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> getConnectionDescriptor() {
-        return connectionClass;
+        return connectionDescriptor;
     }
 
     protected C getSpecificUnconnectedConnection() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/SmackIntegrationTestFramework.java

@@ -48,6 +48,7 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import org.jivesoftware.smack.AbstractXMPPConnection;
+import org.jivesoftware.smack.ConnectionConfiguration;
 import org.jivesoftware.smack.ConnectionConfiguration.SecurityMode;
 import org.jivesoftware.smack.Smack;
 import org.jivesoftware.smack.SmackConfiguration;
@@ -199,8 +200,8 @@ public class SmackIntegrationTestFramework {
         Set<Class<? extends AbstractSmackIntegrationTest>> inttestClasses = reflections.getSubTypesOf(AbstractSmackIntegrationTest.class);
         Set<Class<? extends AbstractSmackLowLevelIntegrationTest>> lowLevelInttestClasses = reflections.getSubTypesOf(AbstractSmackLowLevelIntegrationTest.class);
 
-        Set<Class<? extends AbstractSmackIntTest>> classes = new HashSet<>(inttestClasses.size()
+        final int builtInTestCount = inttestClasses.size() + lowLevelInttestClasses.size();
-                        + lowLevelInttestClasses.size());
+        Set<Class<? extends AbstractSmackIntTest>> classes = new HashSet<>(builtInTestCount);
         classes.addAll(inttestClasses);
         classes.addAll(lowLevelInttestClasses);
 
@@ -333,11 +334,11 @@ public class SmackIntegrationTestFramework {
                 continue;
             }
 
-            Class<? extends AbstractXMPPConnection> specificLowLevelConnectionClass = null;
+            XmppConnectionDescriptor<?, ?, ?> specificLowLevelConnectionDescriptor = null;
             final TestType testType;
             if (test instanceof AbstractSmackSpecificLowLevelIntegrationTest) {
                 AbstractSmackSpecificLowLevelIntegrationTest<?> specificLowLevelTest = (AbstractSmackSpecificLowLevelIntegrationTest<?>) test;
-                specificLowLevelConnectionClass = specificLowLevelTest.getConnectionClass();
+                specificLowLevelConnectionDescriptor = specificLowLevelTest.getConnectionDescriptor();
                 testType = TestType.SpecificLowLevel;
             } else if (test instanceof AbstractSmackLowLevelIntegrationTest) {
                 testType = TestType.LowLevel;
@@ -366,6 +367,7 @@ public class SmackIntegrationTestFramework {
                     verifyLowLevelTestMethod(method, AbstractXMPPConnection.class);
                     break;
                 case SpecificLowLevel:
+                    Class<? extends AbstractXMPPConnection> specificLowLevelConnectionClass = specificLowLevelConnectionDescriptor.getConnectionClass();
                     verifyLowLevelTestMethod(method, specificLowLevelConnectionClass);
                     break;
                 }
@@ -543,10 +545,8 @@ public class SmackIntegrationTestFramework {
                 continue;
             }
 
-            Class<? extends AbstractXMPPConnection> connectionClass = connectionDescriptor.getConnectionClass();
+            ConcreteTest.Executor executor = () -> lowLevelTestMethod.invoke(test, connectionDescriptor);
-
+            ConcreteTest concreteTest = new ConcreteTest(TestType.LowLevel, lowLevelTestMethod.testMethod, executor, connectionDescriptor.getNickname());
-            ConcreteTest.Executor executor = () -> lowLevelTestMethod.invoke(test, connectionClass);
-            ConcreteTest concreteTest = new ConcreteTest(TestType.LowLevel, lowLevelTestMethod.testMethod, executor, connectionClass.getSimpleName());
             resultingConcreteTests.add(concreteTest);
         }
 
@@ -560,8 +560,9 @@ public class SmackIntegrationTestFramework {
         if (testMethod.smackIntegrationTestAnnotation.onlyDefaultConnectionType()) {
             throw new IllegalArgumentException("SpecificLowLevelTests must not have set onlyDefaultConnectionType");
         }
-        Class<C> connectionClass = test.getConnectionClass();
+
-        testMethod.invoke(test, connectionClass);
+        XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor = test.getConnectionDescriptor();
+        testMethod.invoke(test, connectionDescriptor);
     }
 
     protected SmackIntegrationTestEnvironment prepareEnvironment() throws SmackException,
@@ -837,9 +838,8 @@ public class SmackIntegrationTestFramework {
             parameterListOfConnections = testMethodParametersIsListOfConnections(testMethod);
         }
 
-        // TODO: The second parameter should probably be a connection descriptor?
         private void invoke(AbstractSmackLowLevelIntegrationTest test,
-                        Class<? extends AbstractXMPPConnection> connectionClass)
+                        XmppConnectionDescriptor<?, ?, ?> connectionDescriptor)
                         throws IllegalAccessException, IllegalArgumentException, InvocationTargetException,
                         InterruptedException, SmackException, IOException, XMPPException {
             final int connectionCount;
@@ -854,7 +854,7 @@ public class SmackIntegrationTestFramework {
             }
 
             List<? extends AbstractXMPPConnection> connections = connectionManager.constructConnectedConnections(
-                            connectionClass, connectionCount);
+                            connectionDescriptor, connectionCount);
 
             if (parameterListOfConnections) {
                 testMethod.invoke(test, connections);

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/XmppConnectionDescriptor.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2018-2020 Florian Schmaus
+ * Copyright 2018-2021 Florian Schmaus
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
 package org.igniterealtime.smack.inttest;
 
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -29,7 +30,12 @@ import java.util.List;
 import org.jivesoftware.smack.AbstractXMPPConnection;
 import org.jivesoftware.smack.ConnectionConfiguration;
 import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnection;
+import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnectionConfiguration;
+import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnectionModuleDescriptor;
 import org.jivesoftware.smack.util.Consumer;
+import org.jivesoftware.smack.websocket.XmppWebSocketTransportModuleDescriptor;
+import org.jivesoftware.smack.websocket.impl.WebSocketFactory;
 
 public final class XmppConnectionDescriptor<
     C extends AbstractXMPPConnection,
@@ -134,6 +140,32 @@ public final class XmppConnectionDescriptor<
         return new Builder<>(connectionClass, connectionConfigurationClass, connectionConfigurationBuilderClass);
     }
 
+    public static XmppConnectionDescriptor<ModularXmppClientToServerConnection, ModularXmppClientToServerConnectionConfiguration, ModularXmppClientToServerConnectionConfiguration.Builder> buildWebsocketDescriptor(
+                    String nickname, Class<? extends WebSocketFactory> factoryClass)
+                    throws InstantiationException, IllegalAccessException, IllegalArgumentException,
+                    InvocationTargetException, NoSuchMethodException, SecurityException {
+        WebSocketFactory factory;
+        try {
+            Field instanceField = factoryClass.getField("INSTANCE");
+            factory = (WebSocketFactory) instanceField.get(null);
+        } catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException e) {
+            factory = factoryClass.getConstructor().newInstance();
+        }
+        WebSocketFactory finalFactory = factory;
+
+        return XmppConnectionDescriptor.buildWith(ModularXmppClientToServerConnection.class, ModularXmppClientToServerConnectionConfiguration.class, ModularXmppClientToServerConnectionConfiguration.Builder.class)
+        .withNickname("modular-websocket-java11")
+        .applyExtraConfguration(cb -> {
+            cb.removeAllModules();
+            ModularXmppClientToServerConnectionModuleDescriptor webSocketModuleDescriptor =
+                            XmppWebSocketTransportModuleDescriptor.getBuilder(cb)
+                            .setWebSocketFactory(finalFactory)
+                            .build();
+            cb.addModule(webSocketModuleDescriptor);
+        })
+        .build();
+    }
+
     public static final class Builder<C extends AbstractXMPPConnection, CC extends ConnectionConfiguration, CCB extends ConnectionConfiguration.Builder<?, CC>> {
         private final Class<C> connectionClass;
         private final Class<CC> connectionConfigurationClass;

smack-integration-test/src/main/java/org/igniterealtime/smack/inttest/XmppConnectionManager.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2018-2020 Florian Schmaus
+ * Copyright 2018-2021 Florian Schmaus
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -44,8 +45,8 @@ import org.jivesoftware.smack.tcp.XMPPTCPConnection;
 import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
 import org.jivesoftware.smack.util.MultiMap;
 import org.jivesoftware.smack.util.StringUtils;
-import org.jivesoftware.smack.websocket.XmppWebSocketTransportModuleDescriptor;
+import org.jivesoftware.smack.websocket.java11.Java11WebSocketFactory;
-
+import org.jivesoftware.smack.websocket.okhttp.OkHttpWebSocketFactory;
 import org.jivesoftware.smackx.admin.ServiceAdministrationManager;
 import org.jivesoftware.smackx.iqregister.AccountManager;
 
@@ -88,15 +89,13 @@ public class XmppConnectionManager {
                             .build()
             );
             addConnectionDescriptor(
-                    XmppConnectionDescriptor.buildWith(ModularXmppClientToServerConnection.class, ModularXmppClientToServerConnectionConfiguration.class, ModularXmppClientToServerConnectionConfiguration.Builder.class)
+                            XmppConnectionDescriptor.buildWebsocketDescriptor("modular-websocket-okhttp", OkHttpWebSocketFactory.class)
-                    .withNickname("modular-websocket")
-                    .applyExtraConfguration(cb -> {
-                        cb.removeAllModules();
-                        cb.addModule(XmppWebSocketTransportModuleDescriptor.class);
-                    })
-                    .build()
             );
-        } catch (NoSuchMethodException | SecurityException e) {
+            addConnectionDescriptor(
+                            XmppConnectionDescriptor.buildWebsocketDescriptor("modular-websocket-java11", Java11WebSocketFactory.class)
+            );
+        } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException
+                        | IllegalArgumentException | InvocationTargetException e) {
             throw new AssertionError(e);
         }
     }
@@ -155,12 +154,12 @@ public class XmppConnectionManager {
     /**
      * A pool of authenticated and free to use connections.
      */
-    private final MultiMap<Class<? extends AbstractXMPPConnection>, AbstractXMPPConnection> connectionPool = new MultiMap<>();
+    private final MultiMap<XmppConnectionDescriptor<?, ?, ?>, AbstractXMPPConnection> connectionPool = new MultiMap<>();
 
     /**
      * A list of all ever created connections.
      */
-    private final List<AbstractXMPPConnection> connections = new ArrayList<>();
+    private final Map<AbstractXMPPConnection, XmppConnectionDescriptor<?, ?, ?>> connections = new ConcurrentHashMap<>();
 
     XmppConnectionManager(SmackIntegrationTestFramework sinttestFramework)
             throws SmackException, IOException, XMPPException, InterruptedException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
@@ -249,7 +248,7 @@ public class XmppConnectionManager {
 
     void disconnectAndCleanup() throws InterruptedException {
         int successfullyDeletedAccountsCount = 0;
-        for (AbstractXMPPConnection connection : connections) {
+        for (AbstractXMPPConnection connection : connections.keySet()) {
             if (sinttestConfiguration.accountRegistration == AccountRegistration.inBandRegistration) {
                 // Note that we use the account manager from the to-be-deleted connection.
                 AccountManager accountManager = AccountManager.getInstance(connection);
@@ -345,7 +344,7 @@ public class XmppConnectionManager {
             }
         });
 
-        connections.add(mainConnection);
+        connections.put(mainConnection, defaultConnectionDescriptor);
 
         mainConnection.connect();
         mainConnection.login();
@@ -384,13 +383,13 @@ public class XmppConnectionManager {
         }
     }
 
-    <C extends AbstractXMPPConnection> List<C> constructConnectedConnections(Class<C> connectionClass, int count)
+    <C extends AbstractXMPPConnection> List<C> constructConnectedConnections(XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>  connectionDescriptor, int count)
                     throws InterruptedException, SmackException, IOException, XMPPException {
         List<C> connections = new ArrayList<>(count);
 
         synchronized (connectionPool) {
             @SuppressWarnings("unchecked")
-            List<C> pooledConnections = (List<C>) connectionPool.getAll(connectionClass);
+            List<C> pooledConnections = (List<C>) connectionPool.getAll(connectionDescriptor);
             while (count > 0 && !pooledConnections.isEmpty()) {
                 C connection = pooledConnections.remove(pooledConnections.size() - 1);
                 connections.add(connection);
@@ -398,9 +397,6 @@ public class XmppConnectionManager {
             }
         }
 
-        @SuppressWarnings("unchecked")
-        XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor = (XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>) connectionDescriptors
-                .getFirst(connectionClass);
         for (int i = 0; i < count; i++) {
             C connection = constructConnectedConnection(connectionDescriptor);
             connections.add(connection);
@@ -469,7 +465,7 @@ public class XmppConnectionManager {
             throw new IllegalStateException(e);
         }
 
-        connections.add(connection);
+        connections.put(connection, connectionDescriptor);
 
         return connection;
     }
@@ -487,8 +483,13 @@ public class XmppConnectionManager {
         }
 
         if (connection.isAuthenticated()) {
+            XmppConnectionDescriptor<?, ?, ?> connectionDescriptor = connections.get(connection);
+            if (connectionDescriptor == null) {
+                throw new IllegalStateException("Attempt to recycle unknown connection: " + connection);
+            }
+
             synchronized (connectionPool) {
-                connectionPool.put(connectionClass, connection);
+                connectionPool.put(connectionDescriptor, connection);
             }
         } else {
             connection.disconnect();

smack-integration-test/src/main/java/org/jivesoftware/smack/c2s/SimpleXmppConnectionIntegrationTest.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2020 Aditya Borikar
+ * Copyright 2021 Florian Schmaus, 2020 Aditya Borikar
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,28 +16,31 @@
  */
 package org.jivesoftware.smack.c2s;
 
+import java.util.List;
 import java.util.concurrent.TimeoutException;
 
+import org.jivesoftware.smack.AbstractXMPPConnection;
 import org.jivesoftware.smack.StanzaListener;
 import org.jivesoftware.smack.filter.MessageWithBodiesFilter;
 import org.jivesoftware.smack.packet.Message;
 import org.jivesoftware.smack.packet.Stanza;
 
-import org.igniterealtime.smack.inttest.AbstractSmackIntegrationTest;
+import org.igniterealtime.smack.inttest.AbstractSmackLowLevelIntegrationTest;
 import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
 import org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest;
 import org.igniterealtime.smack.inttest.util.SimpleResultSyncPoint;
 
 import org.jxmpp.jid.EntityFullJid;
 
-public class SimpleXmppConnectionIntegrationTest extends AbstractSmackIntegrationTest {
+public class SimpleXmppConnectionIntegrationTest extends AbstractSmackLowLevelIntegrationTest {
 
     public SimpleXmppConnectionIntegrationTest(SmackIntegrationTestEnvironment environment) {
         super(environment);
     }
 
-    @SmackIntegrationTest
+    @SmackIntegrationTest(connectionCount = 2)
-    public void createConnectionTest() throws TimeoutException, Exception {
+    public void createConnectionTest(List<AbstractXMPPConnection> connections) throws TimeoutException, Exception {
+        final AbstractXMPPConnection conOne = connections.get(0), conTwo = connections.get(1);
         EntityFullJid userTwo = conTwo.getUser();
 
         final String messageBody = testRunId + ": Hello from the other side!";

smack-tcp/src/main/java/org/jivesoftware/smack/tcp/XmppTcpTransportModule.java

@@ -664,7 +664,6 @@ public class XmppTcpTransportModule extends ModularXmppClientToServerConnectionM
             return tlsState.engine.getSession();
         }
 
-        @Override
         public boolean isConnected() {
             SocketChannel socketChannel = XmppTcpTransportModule.this.socketChannel;
             if (socketChannel == null) {

smack-websocket-java11/build.gradle

@@ -0,0 +1,8 @@
+description = """\
+Smack for XMPP connections over WebSocket (RFC 7395) using java.net.http.WebSocket."""
+
+dependencies {
+	api project(':smack-websocket')
+
+	testFixturesApi(testFixtures(project(':smack-websocket')))
+}

smack-websocket-java11/src/main/java/org/jivesoftware/smack/websocket/java11/Java11WebSocket.java

@@ -0,0 +1,164 @@
+/**
+ *
+ * Copyright 2021 Florian Schmaus
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smack.websocket.java11;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.WebSocket;
+import java.nio.ByteBuffer;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+
+import javax.net.ssl.SSLSession;
+
+import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
+import org.jivesoftware.smack.util.LazyStringBuilder;
+import org.jivesoftware.smack.websocket.impl.AbstractWebSocket;
+import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
+
+public final class Java11WebSocket extends AbstractWebSocket {
+
+    private static final HttpClient HTTP_CLIENT = HttpClient.newBuilder().build();
+
+    private WebSocket webSocket;
+
+    enum PingPong {
+        ping,
+        pong,
+    };
+
+    Java11WebSocket(WebSocketRemoteConnectionEndpoint endpoint,
+                    ModularXmppClientToServerConnectionInternal connectionInternal) {
+        super(endpoint, connectionInternal);
+
+        final WebSocket.Listener listener = new WebSocket.Listener() {
+            @Override
+            public void onOpen(WebSocket webSocket) {
+                LOGGER.finer(webSocket + " opened");
+                webSocket.request(1);
+            }
+
+            LazyStringBuilder received = new LazyStringBuilder();
+
+            @Override
+            public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
+                received.append(data);
+                webSocket.request(1);
+
+                if (last) {
+                    String wholeMessage = received.toString();
+                    received = new LazyStringBuilder();
+                    onIncomingWebSocketElement(wholeMessage);
+                }
+
+                return null;
+            }
+
+            @Override
+            public void onError(WebSocket webSocket, Throwable error) {
+                onWebSocketFailure(error);
+            }
+
+            @Override
+            public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
+                LOGGER.finer(webSocket + " closed with status code " + statusCode + ". Provided reason: " + reason);
+                // TODO: What should we do here? What if some server implementation closes the WebSocket out of the
+                // blue? Ideally, we should react on this. Some situation in the okhttp implementation.
+                return null;
+            }
+
+            @Override
+            public CompletionStage<?> onPing(WebSocket webSocket, ByteBuffer message) {
+                logPingPong(PingPong.ping, webSocket, message);
+
+                webSocket.request(1);
+                return null;
+            }
+
+            @Override
+            public CompletionStage<?> onPong(WebSocket webSocket, ByteBuffer message) {
+                logPingPong(PingPong.pong, webSocket, message);
+
+                webSocket.request(1);
+                return null;
+            }
+
+            private void logPingPong(PingPong pingPong, WebSocket webSocket, ByteBuffer message) {
+                final Level pingPongLogLevel = Level.FINER;
+                if (!LOGGER.isLoggable(pingPongLogLevel)) {
+                    return;
+                }
+
+                LOGGER.log(pingPongLogLevel, "Received " + pingPong + " over " + webSocket + ". Message: " + message);
+            }
+        };
+
+        final URI uri = endpoint.getUri();
+        CompletionStage<WebSocket> webSocketFuture = HTTP_CLIENT.newWebSocketBuilder()
+                        .subprotocols(SEC_WEBSOCKET_PROTOCOL_HEADER_FILED_VALUE_XMPP)
+                        .buildAsync(uri, listener);
+
+        webSocketFuture.whenComplete((webSocket, throwable) -> {
+            if (throwable == null) {
+                this.webSocket = webSocket;
+                future.setResult(this);
+            } else {
+                onWebSocketFailure(throwable);
+            }
+        });
+    }
+
+    @Override
+    protected void send(String element) {
+        CompletableFuture<WebSocket> completableFuture = webSocket.sendText(element, true);
+        try {
+            completableFuture.get();
+        } catch (ExecutionException e) {
+            onWebSocketFailure(e);
+        } catch (InterruptedException e) {
+            // This thread should never be interrupted, as it is a Smack internal thread.
+            throw new AssertionError(e);
+        }
+    }
+
+    @Override
+    public void disconnect(int code, String message) {
+        CompletableFuture<WebSocket> completableFuture = webSocket.sendClose(code, message);
+        try {
+            completableFuture.get();
+        } catch (ExecutionException e) {
+            onWebSocketFailure(e);
+        } catch (InterruptedException e) {
+            // This thread should never be interrupted, as it is a Smack internal thread.
+            throw new AssertionError(e);
+        } finally {
+            webSocket.abort();
+        }
+    }
+
+    @Override
+    public SSLSession getSSLSession() {
+        return null;
+    }
+
+    private void onWebSocketFailure(ExecutionException executionException) {
+        Throwable cause = executionException.getCause();
+        onWebSocketFailure(cause);
+    }
+}

smack-websocket-java11/src/main/java/org/jivesoftware/smack/websocket/java11/Java11WebSocketFactory.java

@@ -0,0 +1,33 @@
+/**
+ *
+ * Copyright 2021 Florian Schmaus
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smack.websocket.java11;
+
+import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
+import org.jivesoftware.smack.websocket.impl.WebSocketFactory;
+import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
+
+public class Java11WebSocketFactory implements WebSocketFactory {
+
+    public static final Java11WebSocketFactory INSTANCE = new Java11WebSocketFactory();
+
+    @Override
+    public Java11WebSocket create(WebSocketRemoteConnectionEndpoint endpoint,
+                    ModularXmppClientToServerConnectionInternal connectionInternal) {
+        return new Java11WebSocket(endpoint, connectionInternal);
+    }
+
+}

smack-websocket-java11/src/main/java/org/jivesoftware/smack/websocket/java11/package-info.java

@@ -0,0 +1,21 @@
+/**
+ *
+ * Copyright 2021 Florian Schmaus
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * WebSocket support for Smack using {@link java.net.http.WebSocket}, which is available since Java 11.
+ */
+package org.jivesoftware.smack.websocket.java11;

smack-websocket-java11/src/main/resources/META-INF/services/org.jivesoftware.smack.websocket.impl.WebSocketFactory

@@ -0,0 +1 @@
+org.jivesoftware.smack.websocket.java11.Java11WebSocketFactory

smack-websocket-okhttp/src/main/java/org/jivesoftware/smack/websocket/okhttp/OkHttpWebSocket.java

@@ -16,15 +16,11 @@
  */
 package org.jivesoftware.smack.websocket.okhttp;
 
-import java.net.URI;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
 import javax.net.ssl.SSLSession;
 
-import org.jivesoftware.smack.SmackFuture;
 import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
-import org.jivesoftware.smack.websocket.WebSocketException;
 import org.jivesoftware.smack.websocket.impl.AbstractWebSocket;
 import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
 
@@ -36,37 +32,21 @@ import okhttp3.WebSocketListener;
 
 public final class OkHttpWebSocket extends AbstractWebSocket {
 
-    private static final Logger LOGGER = Logger.getLogger(OkHttpWebSocket.class.getName());
+    private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient();
-
-    private static final OkHttpClient okHttpClient = new OkHttpClient();
-
-    // This is a potential candidate to be placed into AbstractWebSocket, but I keep it here until smack-websocket-java11
-    // arrives.
-    private final SmackFuture.InternalSmackFuture<AbstractWebSocket, Exception> future = new SmackFuture.InternalSmackFuture<>();
-
-    private final LoggingInterceptor interceptor;
 
     private final WebSocket okHttpWebSocket;
 
-    public OkHttpWebSocket(WebSocketRemoteConnectionEndpoint endpoint,
+    OkHttpWebSocket(WebSocketRemoteConnectionEndpoint endpoint,
                     ModularXmppClientToServerConnectionInternal connectionInternal) {
         super(endpoint, connectionInternal);
 
-        if (connectionInternal.smackDebugger != null) {
+        final String url = endpoint.getRawString();
-            interceptor = new LoggingInterceptor(connectionInternal.smackDebugger);
-        } else {
-            interceptor = null;
-        }
-
-        final URI uri = endpoint.getUri();
-        final String url = uri.toString();
-
         Request request = new Request.Builder()
                               .url(url)
-                              .header("Sec-WebSocket-Protocol", "xmpp")
+                              .header(SEC_WEBSOCKET_PROTOCOL_HEADER_FILED_NAME, SEC_WEBSOCKET_PROTOCOL_HEADER_FILED_VALUE_XMPP)
                               .build();
 
-        okHttpWebSocket = okHttpClient.newWebSocket(request, listener);
+        okHttpWebSocket = OK_HTTP_CLIENT.newWebSocket(request, listener);
     }
 
     private final WebSocketListener listener = new WebSocketListener() {
@@ -75,35 +55,18 @@ public final class OkHttpWebSocket extends AbstractWebSocket {
         public void onOpen(WebSocket webSocket, Response response) {
             LOGGER.log(Level.FINER, "OkHttp invoked onOpen() for {0}. Response: {1}",
                             new Object[] { webSocket, response });
-
-            if (interceptor != null) {
-                interceptor.interceptOpenResponse(response);
-            }
-
             future.setResult(OkHttpWebSocket.this);
         }
 
         @Override
         public void onMessage(WebSocket webSocket, String text) {
-            if (interceptor != null) {
-                interceptor.interceptReceivedText(text);
-            }
-
             onIncomingWebSocketElement(text);
         }
 
         @Override
         public void onFailure(WebSocket webSocket, Throwable throwable, Response response) {
             LOGGER.log(Level.FINER, "OkHttp invoked onFailure() for " + webSocket + ". Response: " + response, throwable);
-            WebSocketException websocketException = new WebSocketException(throwable);
+            onWebSocketFailure(throwable);
-
-            // If we are already connected, then we need to notify the connection that it got tear down. Otherwise we
-            // need to notify the thread calling connect() that the connection failed.
-            if (future.wasSuccessful()) {
-                connectionInternal.notifyConnectionError(websocketException);
-            } else {
-                future.setException(websocketException);
-            }
         }
 
         @Override
@@ -118,16 +81,8 @@ public final class OkHttpWebSocket extends AbstractWebSocket {
 
     };
 
-    @Override
-    public SmackFuture<AbstractWebSocket, Exception> getFuture() {
-        return future;
-    }
-
     @Override
     public void send(String element) {
-        if (interceptor != null) {
-            interceptor.interceptSentText(element);
-        }
         okHttpWebSocket.send(element);
     }
 
@@ -137,17 +92,6 @@ public final class OkHttpWebSocket extends AbstractWebSocket {
         okHttpWebSocket.close(code, message);
     }
 
-    @Override
-    public boolean isConnectionSecure() {
-        return endpoint.isSecureEndpoint();
-    }
-
-    @Override
-    public boolean isConnected() {
-        // TODO: Do we need this method at all if we create an AbstractWebSocket object for every endpoint?
-        return true;
-    }
-
     @Override
     public SSLSession getSSLSession() {
         // TODO: What shall we do about this method, as it appears that OkHttp does not provide access to the used SSLSession?

smack-websocket-okhttp/src/main/java/org/jivesoftware/smack/websocket/okhttp/OkHttpWebSocketFactory.java

@@ -23,6 +23,8 @@ import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
 
 public class OkHttpWebSocketFactory implements WebSocketFactory {
 
+    public static final OkHttpWebSocketFactory INSTANCE = new OkHttpWebSocketFactory();
+
     @Override
     public AbstractWebSocket create(WebSocketRemoteConnectionEndpoint endpoint, ModularXmppClientToServerConnectionInternal connectionInternal) {
         return new OkHttpWebSocket(endpoint, connectionInternal);

smack-websocket/src/main/java/org/jivesoftware/smack/websocket/WebSocketConnectionAttemptState.java

@@ -24,26 +24,28 @@ import org.jivesoftware.smack.SmackFuture;
 import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
 import org.jivesoftware.smack.fsm.StateTransitionResult;
 import org.jivesoftware.smack.util.StringUtils;
-import org.jivesoftware.smack.websocket.XmppWebSocketTransportModule.EstablishingWebSocketConnectionState;
 import org.jivesoftware.smack.websocket.impl.AbstractWebSocket;
-import org.jivesoftware.smack.websocket.impl.WebSocketFactoryService;
+import org.jivesoftware.smack.websocket.impl.WebSocketFactory;
 import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
 import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpointLookup;
 
 public final class WebSocketConnectionAttemptState {
+
     private final ModularXmppClientToServerConnectionInternal connectionInternal;
     private final XmppWebSocketTransportModule.XmppWebSocketTransport.DiscoveredWebSocketEndpoints discoveredEndpoints;
+    private final WebSocketFactory webSocketFactory;
 
     private AbstractWebSocket webSocket;
 
     WebSocketConnectionAttemptState(ModularXmppClientToServerConnectionInternal connectionInternal,
                     XmppWebSocketTransportModule.XmppWebSocketTransport.DiscoveredWebSocketEndpoints discoveredWebSocketEndpoints,
-                    EstablishingWebSocketConnectionState establishingWebSocketConnectionState) {
+                    WebSocketFactory webSocketFactory) {
         assert discoveredWebSocketEndpoints != null;
         assert !discoveredWebSocketEndpoints.result.isEmpty();
 
         this.connectionInternal = connectionInternal;
         this.discoveredEndpoints = discoveredWebSocketEndpoints;
+        this.webSocketFactory = webSocketFactory;
     }
 
     /**
@@ -87,7 +89,7 @@ public final class WebSocketConnectionAttemptState {
             List<AbstractWebSocket> webSockets = new ArrayList<>(endpointCount);
             // First only create the AbstractWebSocket instances, in case a constructor throws.
             for (WebSocketRemoteConnectionEndpoint endpoint : webSocketEndpoints) {
-                AbstractWebSocket webSocket = WebSocketFactoryService.createWebSocket(endpoint, connectionInternal);
+                AbstractWebSocket webSocket = webSocketFactory.create(endpoint, connectionInternal);
                 webSockets.add(webSocket);
             }
 

smack-websocket/src/main/java/org/jivesoftware/smack/websocket/XmppWebSocketTransportModule.java

@@ -50,6 +50,8 @@ import org.jivesoftware.smack.websocket.XmppWebSocketTransportModule.XmppWebSock
 import org.jivesoftware.smack.websocket.elements.WebSocketCloseElement;
 import org.jivesoftware.smack.websocket.elements.WebSocketOpenElement;
 import org.jivesoftware.smack.websocket.impl.AbstractWebSocket;
+import org.jivesoftware.smack.websocket.impl.WebSocketFactory;
+import org.jivesoftware.smack.websocket.impl.WebSocketFactoryService;
 import org.jivesoftware.smack.websocket.rce.InsecureWebSocketRemoteConnectionEndpoint;
 import org.jivesoftware.smack.websocket.rce.SecureWebSocketRemoteConnectionEndpoint;
 import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
@@ -63,6 +65,9 @@ import org.jxmpp.jid.DomainBareJid;
  */
 public final class XmppWebSocketTransportModule
                 extends ModularXmppClientToServerConnectionModule<XmppWebSocketTransportModuleDescriptor> {
+
+    private static final int WEBSOCKET_NORMAL_CLOSURE = 1000;
+
     private final XmppWebSocketTransport websocketTransport;
 
     private AbstractWebSocket websocket;
@@ -106,8 +111,15 @@ public final class XmppWebSocketTransportModule
         @Override
         public AttemptResult transitionInto(WalkStateGraphContext walkStateGraphContext) throws InterruptedException,
                         NoResponseException, NotConnectedException, SmackException, XMPPException {
+            final WebSocketFactory webSocketFactory;
+            if (moduleDescriptor.webSocketFactory != null) {
+                webSocketFactory = moduleDescriptor.webSocketFactory;
+            } else {
+                webSocketFactory = WebSocketFactoryService::createWebSocket;
+            }
+
             WebSocketConnectionAttemptState connectionAttemptState = new WebSocketConnectionAttemptState(
-                            connectionInternal, discoveredWebSocketEndpoints, this);
+                            connectionInternal, discoveredWebSocketEndpoints, webSocketFactory);
 
             StateTransitionResult.Failure failure = connectionAttemptState.establishWebSocketConnection();
             if (failure != null) {
@@ -246,7 +258,7 @@ public final class XmppWebSocketTransportModule
 
         @Override
         protected void disconnect() {
-            websocket.disconnect(1000, "WebSocket closed normally");
+            websocket.disconnect(WEBSOCKET_NORMAL_CLOSURE, "WebSocket closed normally");
         }
 
         @Override
@@ -269,11 +281,6 @@ public final class XmppWebSocketTransportModule
             return websocket.isConnectionSecure();
         }
 
-        @Override
-        public boolean isConnected() {
-            return websocket.isConnected();
-        }
-
         @Override
         public Stats getStats() {
             return null;

smack-websocket/src/main/java/org/jivesoftware/smack/websocket/XmppWebSocketTransportModuleDescriptor.java

@@ -30,6 +30,7 @@ import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionIn
 import org.jivesoftware.smack.fsm.StateDescriptor;
 import org.jivesoftware.smack.util.Objects;
 import org.jivesoftware.smack.websocket.XmppWebSocketTransportModule.EstablishingWebSocketConnectionStateDescriptor;
+import org.jivesoftware.smack.websocket.impl.WebSocketFactory;
 import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
 
 /**
@@ -41,14 +42,16 @@ import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
 public final class XmppWebSocketTransportModuleDescriptor extends ModularXmppClientToServerConnectionModuleDescriptor {
     private final boolean performWebSocketEndpointDiscovery;
     private final boolean implicitWebSocketEndpoint;
-    private final URI uri;
     private final WebSocketRemoteConnectionEndpoint wsRce;
 
+    final WebSocketFactory webSocketFactory;
+
     public XmppWebSocketTransportModuleDescriptor(Builder builder) {
         this.performWebSocketEndpointDiscovery = builder.performWebSocketEndpointDiscovery;
         this.implicitWebSocketEndpoint = builder.implicitWebSocketEndpoint;
+        this.webSocketFactory = builder.webSocketFactory;
 
-        this.uri = builder.uri;
+        URI uri = builder.uri;
         if (uri != null) {
             wsRce = WebSocketRemoteConnectionEndpoint.from(uri);
         } else {
@@ -95,7 +98,7 @@ public final class XmppWebSocketTransportModuleDescriptor extends ModularXmppCli
      * @return uri
      */
     public URI getExplicitlyProvidedUri() {
-        return uri;
+        return wsRce.getUri();
     }
 
     WebSocketRemoteConnectionEndpoint getExplicitlyProvidedEndpoint() {
@@ -142,6 +145,7 @@ public final class XmppWebSocketTransportModuleDescriptor extends ModularXmppCli
         private boolean performWebSocketEndpointDiscovery = true;
         private boolean implicitWebSocketEndpoint = true;
         private URI uri;
+        private WebSocketFactory webSocketFactory;
 
         private Builder(
                 ModularXmppClientToServerConnectionConfiguration.Builder connectionConfigurationBuilder) {
@@ -175,6 +179,12 @@ public final class XmppWebSocketTransportModuleDescriptor extends ModularXmppCli
             return this;
         }
 
+        public Builder setWebSocketFactory(WebSocketFactory webSocketFactory) {
+            Objects.requireNonNull(webSocketFactory);
+            this.webSocketFactory = webSocketFactory;
+            return this;
+        }
+
         @Override
         public ModularXmppClientToServerConnectionModuleDescriptor build() {
             return new XmppWebSocketTransportModuleDescriptor(this);

smack-websocket/src/main/java/org/jivesoftware/smack/websocket/impl/AbstractWebSocket.java

@@ -16,24 +16,44 @@
  */
 package org.jivesoftware.smack.websocket.impl;
 
+import java.util.logging.Logger;
+
 import javax.net.ssl.SSLSession;
 
 import org.jivesoftware.smack.SmackFuture;
 import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
+import org.jivesoftware.smack.debugger.SmackDebugger;
 import org.jivesoftware.smack.packet.TopLevelStreamElement;
 import org.jivesoftware.smack.packet.XmlEnvironment;
+import org.jivesoftware.smack.websocket.WebSocketException;
 import org.jivesoftware.smack.websocket.rce.WebSocketRemoteConnectionEndpoint;
 
 public abstract class AbstractWebSocket {
 
+    protected static final Logger LOGGER = Logger.getLogger(AbstractWebSocket.class.getName());
+
+    protected static final String SEC_WEBSOCKET_PROTOCOL_HEADER_FILED_NAME = "Sec-WebSocket-Protocol";
+    protected static final String SEC_WEBSOCKET_PROTOCOL_HEADER_FILED_VALUE_XMPP = "xmpp";
+
+    protected final SmackFuture.InternalSmackFuture<AbstractWebSocket, Exception> future = new SmackFuture.InternalSmackFuture<>();
+
     protected final ModularXmppClientToServerConnectionInternal connectionInternal;
 
     protected final WebSocketRemoteConnectionEndpoint endpoint;
 
+    private final SmackWebSocketDebugger debugger;
+
     protected AbstractWebSocket(WebSocketRemoteConnectionEndpoint endpoint,
                     ModularXmppClientToServerConnectionInternal connectionInternal) {
         this.endpoint = endpoint;
         this.connectionInternal = connectionInternal;
+
+        final SmackDebugger smackDebugger = connectionInternal.smackDebugger;
+        if (smackDebugger != null) {
+            debugger = new SmackWebSocketDebugger(smackDebugger);
+        } else {
+            debugger = null;
+        }
     }
 
     public final WebSocketRemoteConnectionEndpoint getEndpoint() {
@@ -44,6 +64,10 @@ public abstract class AbstractWebSocket {
     private String streamClose;
 
     protected final void onIncomingWebSocketElement(String element) {
+        if (debugger != null) {
+            debugger.incoming(element);
+        }
+
         // TODO: Once smack-websocket-java15 is there, we have to re-evaluate if the async operation here is still
         // required, or if it should only be performed if OkHTTP is used.
         if (isOpenElement(element)) {
@@ -95,11 +119,31 @@ public abstract class AbstractWebSocket {
         return false;
     }
 
-    public abstract SmackFuture<AbstractWebSocket, Exception> getFuture();
+    protected void onWebSocketFailure(Throwable throwable) {
+        WebSocketException websocketException = new WebSocketException(throwable);
+
+        // If we are already connected, then we need to notify the connection that it got tear down. Otherwise we
+        // need to notify the thread calling connect() that the connection failed.
+        if (future.wasSuccessful()) {
+            connectionInternal.notifyConnectionError(websocketException);
+        } else {
+            future.setException(websocketException);
+        }
+    }
+
+    public final SmackFuture<AbstractWebSocket, Exception> getFuture() {
+        return future;
+    }
 
     public final void send(TopLevelStreamElement element) {
         XmlEnvironment outgoingStreamXmlEnvironment = connectionInternal.getOutgoingStreamXmlEnvironment();
         String elementString = element.toXML(outgoingStreamXmlEnvironment).toString();
+
+        // TODO: We could make use of Java 11's WebSocket (is)last feature when sending
+        if (debugger != null) {
+            debugger.outgoing(elementString);
+        }
+
         send(elementString);
     }
 
@@ -107,9 +151,9 @@ public abstract class AbstractWebSocket {
 
     public abstract void disconnect(int code, String message);
 
-    public abstract boolean isConnectionSecure();
+    public boolean isConnectionSecure() {
+        return endpoint.isSecureEndpoint();
+    }
 
     public abstract SSLSession getSSLSession();
-
-    public abstract boolean isConnected();
 }

smack-websocket/src/main/java/org/jivesoftware/smack/websocket/impl/SmackWebSocketDebugger.java

@@ -14,57 +14,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.jivesoftware.smack.websocket.okhttp;
+package org.jivesoftware.smack.websocket.impl;
 
 import java.io.IOException;
-import java.util.Iterator;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import org.jivesoftware.smack.debugger.SmackDebugger;
 
-import okhttp3.Headers;
-import okhttp3.Response;
-
 import org.jxmpp.xml.splitter.XmlPrettyPrinter;
 import org.jxmpp.xml.splitter.XmppXmlSplitter;
 
-public final class LoggingInterceptor {
+public class SmackWebSocketDebugger {
-    private static final Logger LOGGER = Logger.getLogger(LoggingInterceptor.class.getName());
+
+    private static final Logger LOGGER = Logger.getLogger(SmackWebSocketDebugger.class.getName());
 
     private final SmackDebugger debugger;
     private final XmppXmlSplitter incomingXmlSplitter;
     private final XmppXmlSplitter outgoingXmlSplitter;
 
-    LoggingInterceptor(SmackDebugger smackDebugger) {
+    SmackWebSocketDebugger(SmackDebugger smackDebugger) {
         this.debugger = smackDebugger;
 
         XmlPrettyPrinter incomingTextPrinter = XmlPrettyPrinter.builder()
-                                    .setPrettyWriter(sb -> debugger.incomingStreamSink(sb))
+                        .setPrettyWriter(sb -> debugger.incomingStreamSink(sb))
-                                    .setTabWidth(4)
+                        .setTabWidth(4)
-                                    .build();
+                        .build();
         incomingXmlSplitter = new XmppXmlSplitter(incomingTextPrinter);
 
         XmlPrettyPrinter outgoingTextPrinter = XmlPrettyPrinter.builder()
-                .setPrettyWriter(sb -> debugger.outgoingStreamSink(sb))
+                        .setPrettyWriter(sb -> debugger.outgoingStreamSink(sb))
-                .setTabWidth(4)
+                        .setTabWidth(4)
-                .build();
+                        .build();
         outgoingXmlSplitter = new XmppXmlSplitter(outgoingTextPrinter);
     }
 
-    // Open response received here isn't in the form of an Xml an so, there isn't much to format.
+    void incoming(String text) {
-    void interceptOpenResponse(Response response) {
-       Headers headers = response.headers();
-       Iterator<?> iterator = headers.iterator();
-       StringBuilder sb = new StringBuilder();
-       sb.append("Received headers:");
-       while (iterator.hasNext()) {
-           sb.append("\n\t" + iterator.next());
-       }
-       debugger.incomingStreamSink(sb);
-    }
-
-    void interceptReceivedText(String text) {
         try {
             incomingXmlSplitter.write(text);
         } catch (IOException e) {
@@ -73,7 +58,7 @@ public final class LoggingInterceptor {
         }
     }
 
-    void interceptSentText(String text) {
+    void outgoing(String text) {
         try {
             outgoingXmlSplitter.write(text);
         } catch (IOException e) {