Changes:

- Fixed bug: library was not working on certain java versions
   due to different WebSocket implementation. Instead of using java websocket api now there is `org.java-websocket`

Client/pom.xml

@@ -29,6 +29,23 @@
             <artifactId>protobuf-java</artifactId>
             <version>3.24.1</version>
         </dependency>
+
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>2.0.7</version>
+        </dependency>
+        <dependency>
+            <groupId>org.java-websocket</groupId>
+            <artifactId>Java-WebSocket</artifactId>
+            <version>1.5.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>2.0.7</version>
+            <scope>runtime</scope>
+        </dependency>
     </dependencies>
 
 

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClientBuilder.java

@@ -70,7 +70,6 @@ public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveCli
         var tiktokRoomInfo = new TikTokRoomInfo();
         tiktokRoomInfo.setUserName(clientSettings.getHostName());
 
-
         var cookieJar = new TikTokCookieJar();
         var requestFactory = new TikTokHttpRequestFactory(cookieJar);
         var apiClient = new TikTokHttpApiClient(cookieJar, requestFactory);
@@ -79,7 +78,6 @@ public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveCli
         var webResponseHandler = new TikTokMessageHandlerRegistration(tikTokEventHandler, clientSettings, logger, giftManager, tiktokRoomInfo);
         var webSocketClient = new TikTokWebSocketClient(logger,
                 cookieJar,
-                requestFactory,
                 clientSettings,
                 webResponseHandler,
                 tikTokEventHandler);

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/TikTokWebSocketClient.java

@@ -11,10 +11,10 @@ import io.github.jwdeveloper.tiktok.http.HttpUtils;
 import io.github.jwdeveloper.tiktok.http.TikTokCookieJar;
 import io.github.jwdeveloper.tiktok.http.TikTokHttpRequestFactory;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+import org.java_websocket.client.WebSocketClient;
 
 import java.net.URI;
 import java.net.http.WebSocket;
-import java.time.Duration;
 import java.util.HashMap;
 import java.util.TreeMap;
 import java.util.logging.Logger;
@@ -23,24 +23,21 @@ public class TikTokWebSocketClient {
     private final Logger logger;
     private final ClientSettings clientSettings;
     private final TikTokCookieJar tikTokCookieJar;
-    private final TikTokHttpRequestFactory factory;
     private final TikTokMessageHandlerRegistration webResponseHandler;
     private final TikTokEventHandler tikTokEventHandler;
 
-    private WebSocket webSocket;
+    private WebSocketClient webSocketClient;
     private boolean isConnected;
     private TikTokLiveClient tikTokLiveClient;
 
     public TikTokWebSocketClient(Logger logger,
                                  TikTokCookieJar tikTokCookieJar,
-                                 TikTokHttpRequestFactory factory,
                                  ClientSettings clientSettings,
                                  TikTokMessageHandlerRegistration webResponseHandler,
                                  TikTokEventHandler tikTokEventHandler) {
         this.logger = logger;
         this.tikTokCookieJar = tikTokCookieJar;
         this.clientSettings = clientSettings;
-        this.factory = factory;
         this.webResponseHandler = webResponseHandler;
         this.tikTokEventHandler = tikTokEventHandler;
         isConnected = false;
@@ -56,12 +53,12 @@ public class TikTokWebSocketClient {
         }
         try {
             var url = getWebSocketUrl(webcastResponse);
-            if (clientSettings.isHandleExistingMessagesOnConnect())
-            {
+            if (clientSettings.isHandleExistingMessagesOnConnect()) {
                 logger.info("Handling existing messages");
                 webResponseHandler.handle(tikTokLiveClient, webcastResponse);
             }
-            webSocket = startWebSocket(url);
+            webSocketClient = startWebSocket(url);
+            webSocketClient.connect();
         } catch (Exception e) {
             throw new TikTokLiveException("Failed to connect to the websocket", e);
         }
@@ -82,20 +79,19 @@ public class TikTokWebSocketClient {
         return HttpUtils.parseParametersEncode(url, clone);
     }
 
-    private WebSocket startWebSocket(String url) throws Exception {
+    private WebSocketClient startWebSocket(String url) {
         var cookie = tikTokCookieJar.parseCookies();
         var map = new HashMap<String, String>();
         map.put("Cookie", cookie);
-        return factory.openSocket()
-                .subprotocols("echo-protocol")
-                .connectTimeout(Duration.ofSeconds(15))
-                .header("Cookie", cookie)
-                .buildAsync(URI.create(url), new TikTokWebSocketListener(webResponseHandler, tikTokEventHandler, tikTokLiveClient)).get();
+
+        return new TikTokWebSocketListener(URI.create(url), map, 3000, webResponseHandler, tikTokEventHandler, tikTokLiveClient);
     }
 
+
+
     public void stop() {
-        if (isConnected && webSocket != null) {
-            webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok");
+        if (isConnected && webSocketClient != null) {
+            webSocketClient.close();
         }
     }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/TikTokWebSocketListener.java

@@ -1,6 +1,5 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
-
 import com.google.protobuf.ByteString;
 import io.github.jwdeveloper.tiktok.TikTokLiveClient;
 import io.github.jwdeveloper.tiktok.events.messages.TikTokConnectedEvent;
@@ -12,71 +11,71 @@ import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketAck;
 import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketMessage;
+import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.drafts.Draft_6455;
+import org.java_websocket.handshake.ServerHandshake;
 
-import java.io.ByteArrayOutputStream;
+import java.net.URI;
 import java.net.http.WebSocket;
 import java.nio.ByteBuffer;
+import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.CompletionStage;
 
+public class TikTokWebSocketListener extends WebSocketClient {
 
-public class TikTokWebSocketListener implements java.net.http.WebSocket.Listener {
-
-    private final ByteArrayOutputStream accumulatedData = new ByteArrayOutputStream();
     private final TikTokMessageHandlerRegistration webResponseHandler;
     private final TikTokEventHandler tikTokEventHandler;
     private final TikTokLiveClient tikTokLiveClient;
 
-    public TikTokWebSocketListener(TikTokMessageHandlerRegistration webResponseHandler,
+    public TikTokWebSocketListener(URI serverUri,
+                                   Map<String, String> httpHeaders,
+                                   int connectTimeout,
+                                   TikTokMessageHandlerRegistration webResponseHandler,
                                    TikTokEventHandler tikTokEventHandler,
                                    TikTokLiveClient tikTokLiveClient) {
+        super(serverUri, new Draft_6455(), httpHeaders,connectTimeout);
         this.webResponseHandler = webResponseHandler;
         this.tikTokEventHandler = tikTokEventHandler;
         this.tikTokLiveClient = tikTokLiveClient;
     }
 
+
     @Override
-    public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
+    public void onOpen(ServerHandshake serverHandshake) {
+        tikTokEventHandler.publish(tikTokLiveClient,new TikTokConnectedEvent());
+        sendPing();
+    }
+
+
+    @Override
+    public void onMessage(ByteBuffer bytes)
+    {
         try {
-            var bytes = new byte[data.remaining()];
-            data.get(bytes);
-            accumulatedData.write(bytes);
-            if (last) {
-                handleBinary(webSocket, accumulatedData.toByteArray());
-                accumulatedData.reset();
-            }
+            handleBinary(bytes.array());
         } catch (Exception e) {
             tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(e));
         }
-        webSocket.request(1);
-        return null;
+        sendPing();
     }
 
     @Override
-    public void onOpen(java.net.http.WebSocket webSocket) {
-        tikTokEventHandler.publish(tikTokLiveClient,new TikTokConnectedEvent());
-        webSocket.request(1);
-    }
-
-    @Override
-    public void onError(java.net.http.WebSocket webSocket, Throwable error) {
-        tikTokEventHandler.publish(tikTokLiveClient,new TikTokErrorEvent(error));
-        webSocket.request(1);
-    }
-
-    @Override
-    public CompletionStage<?> onClose(java.net.http.WebSocket webSocket, int statusCode, String reason) {
+    public void onClose(int i, String s, boolean b) {
         tikTokEventHandler.publish(tikTokLiveClient,new TikTokDisconnectedEvent());
-        return java.net.http.WebSocket.Listener.super.onClose(webSocket, statusCode, reason);
     }
 
-    private void handleBinary(WebSocket webSocket, byte[] buffer) {
+    @Override
+    public void onError(Exception error) {
+        tikTokEventHandler.publish(tikTokLiveClient,new TikTokErrorEvent(error));
+        sendPing();
+    }
+
+    private void handleBinary(byte[] buffer) {
         var websocketMessageOptional = getWebcastWebsocketMessage(buffer);
         if (websocketMessageOptional.isEmpty()) {
             return;
         }
         var websocketMessage = websocketMessageOptional.get();
-        sendAckId(webSocket, websocketMessage.getId());
+        sendAckId(websocketMessage.getId());
 
         var webResponse = getWebResponseMessage(websocketMessage.getBinary());
         webResponseHandler.handle(tikTokLiveClient, webResponse);
@@ -114,13 +113,19 @@ public class TikTokWebSocketListener implements java.net.http.WebSocket.Listener
         }
     }
 
-    private void sendAckId(WebSocket webSocket, long id) {
+    private void sendAckId(long id) {
         var serverInfo = WebcastWebsocketAck
                 .newBuilder()
                 .setType("ack")
                 .setId(id)
                 .build();
-        webSocket.sendBinary(serverInfo.toByteString().asReadOnlyByteBuffer(), true);
+        send(serverInfo.toByteString().asReadOnlyByteBuffer());
     }
 
-}
+
+
+    @Override
+    public void onMessage(String s) {
+
+    }
+}

TestApplication/src/main/java/io/github/jwdeveloper/tiktok/Main.java

@@ -7,7 +7,7 @@ import java.io.IOException;
 
 public class Main {
 
-    public static String TEST_TIKTOK_USER = "vadimpyrography";
+    public static String TEST_TIKTOK_USER = "dmikl_";
 
     public static void main(String[] args) throws IOException {
         var client = TikTokLive.newClient(TEST_TIKTOK_USER)

pom.xml

@@ -54,6 +54,7 @@
                         <configuration>
                             <shadedArtifactAttached>true</shadedArtifactAttached>
                             <shadedClassifierName>all</shadedClassifierName>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
                             <minimizeJar>true</minimizeJar>
                             <artifactSet>
                                 <includes>
@@ -64,8 +65,6 @@
                                 <filter>
                                     <artifact>*:*</artifact>
                                     <excludes>
-                                        <exclude>**/proto/**</exclude>
-                                        <exclude>**/google/**</exclude>
                                         <exclude>**/tiktokSchema.proto/**</exclude>
                                     </excludes>
                                 </filter>
@@ -99,6 +98,8 @@
             <scope>test</scope>
         </dependency>
 
+
+
     </dependencies>
 
 </project>