Update version in pom.xml

* Add .of methods for custom User objects

Adds an extra .of() function that accepts a User object, instead of a username string.

* Use username if profile name not set

* Add combo argument

* Replace WebcastGiftMessage from the new constructor

* Fix argument naming error

* Fix wrong argument order

API/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.10.4-Release</version>
+        <version>1.11.9-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>API</artifactId>

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokDisconnectedEvent.java

@@ -30,14 +30,22 @@ import lombok.Getter;
 @Getter
 @EventMeta(eventType = EventType.Control)
 public class TikTokDisconnectedEvent extends TikTokLiveClientEvent {
+	public static int UNKNOWN_CLOSE_CODE = -1;
+
+	/** Valid CloseFrame code or -1 for unknown */
+	private final int code;
 	private final String reason;
 
-	public TikTokDisconnectedEvent(String reason) {
+	public TikTokDisconnectedEvent(int code, String reason) {
+		this.code = code;
 		this.reason = reason.isBlank() ? "None" : reason;
 	}
 
-	public static TikTokDisconnectedEvent of(String reason)
-	{
-		return new TikTokDisconnectedEvent(reason);
+	public TikTokDisconnectedEvent(String reason) {
+		this(UNKNOWN_CLOSE_CODE, reason);
+	}
+
+	public boolean isUnknownCloseCode() {
+		return this.code == UNKNOWN_CLOSE_CODE;
 	}
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokLinkMicBattleItemCard.java

@@ -0,0 +1,15 @@
+package io.github.jwdeveloper.tiktok.data.events;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicBattleItemCard;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkMicBattleItemCard extends TikTokHeaderEvent {
+
+	public TikTokLinkMicBattleItemCard(WebcastLinkMicBattleItemCard msg) {
+		super(msg.getCommon());
+	}
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/gift/TikTokGiftComboEvent.java

@@ -39,11 +39,16 @@ public class TikTokGiftComboEvent extends TikTokGiftEvent {
         this.comboState = comboState;
     }
 
+    public TikTokGiftComboEvent(Gift gift, User host, User user, int combo, GiftComboStateType comboState) {
+        super(gift, user, host, combo);
+        this.comboState = comboState;
+    }
+
     public static TikTokGiftComboEvent of(Gift gift, int combo, GiftComboStateType comboState) {
-        return new TikTokGiftComboEvent(
-            gift,
-            new User(0L, "Test", new Picture("")),
-            WebcastGiftMessage.newBuilder().setComboCount(combo).build(),
-            comboState);
+        return new TikTokGiftComboEvent(gift, new User(0L, "Test", new Picture("")), WebcastGiftMessage.newBuilder().setComboCount(combo).build(), comboState);
+    }
+
+    public static TikTokGiftComboEvent of(Gift gift, User host, User user, int combo, GiftComboStateType comboState) {
+        return new TikTokGiftComboEvent(gift, host, user, combo, comboState);
     }
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/gift/TikTokGiftEvent.java

@@ -49,17 +49,25 @@ public class TikTokGiftEvent extends TikTokHeaderEvent {
         }
         combo = msg.getComboCount();
     }
-
-    public TikTokGiftEvent(Gift gift) {
+    
+    public TikTokGiftEvent(Gift gift, User user, User toUser, int combo) {
         this.gift = gift;
-        user = new User(0L, "sender", new Picture(""));
-        toUser = new User(0L, "receiver", new Picture(""));
-        combo = 1;
+        this.user = user;
+        this.toUser = toUser;
+        this.combo = combo;
     }
 
-
     public static TikTokGiftEvent of(Gift gift) {
-        return new TikTokGiftEvent(gift);
+        return new TikTokGiftEvent(
+            gift,
+            new User(0L, "sender", new Picture("")),
+            new User(0L, "reviever", new Picture("")),
+            1
+            );
+    }
+
+    public static TikTokGiftEvent of(Gift gift, User user, User toUser) {
+        return new TikTokGiftEvent(gift, user, toUser, 1) ;
     }
 
     public static TikTokGiftEvent of(String name, int id, int diamonds) {

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokFollowEvent.java

@@ -44,10 +44,20 @@ public class TikTokFollowEvent extends TikTokHeaderEvent {
 
     public static TikTokFollowEvent of(String userName) {
         return new TikTokFollowEvent(WebcastSocialMessage.newBuilder()
-                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
-                        .setUsername(userName)
-                        .setNickname(userName)
-                        .build())
-                .build());
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(userName)
+                .setNickname(userName)
+                .build())
+            .build());
+    }
+
+    public static TikTokFollowEvent of(User user) {
+        return new TikTokFollowEvent(WebcastSocialMessage.newBuilder()
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(user.getName())
+                .setNickname(user.getProfileName() != null ? user.getProfileName() : user.getName())
+                .setId(user.getId())
+                .build())
+            .build());
     }
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokJoinEvent.java

@@ -48,13 +48,22 @@ public class TikTokJoinEvent extends TikTokHeaderEvent {
         totalUsers = msg.getMemberCount();
     }
 
-    public static TikTokJoinEvent of(String userName)
-    {
+    public static TikTokJoinEvent of(String userName) {
         return new TikTokJoinEvent(WebcastMemberMessage.newBuilder()
-                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
-                        .setUsername(userName)
-                        .setNickname(userName)
-                        .build())
-                .build());
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(userName)
+                .setNickname(userName)
+                .build())
+            .build());
+    }
+
+    public static TikTokJoinEvent of(User user) {
+        return new TikTokJoinEvent(WebcastMemberMessage.newBuilder()
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(user.getName())
+                .setNickname(user.getProfileName())
+                .setId(user.getId())
+                .build())
+            .build());
     }
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokLikeEvent.java

@@ -56,15 +56,25 @@ public class TikTokLikeEvent extends TikTokHeaderEvent
         totalLikes = msg.getTotal();
     }
 
-    public static TikTokLikeEvent of(String userName, int likes)
-    {
+    public static TikTokLikeEvent of(String userName, int likes) {
         return new TikTokLikeEvent(WebcastLikeMessage.newBuilder()
-                .setCount(likes)
-                .setTotal(likes)
-                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
-                        .setUsername(userName)
-                        .setNickname(userName)
-                        .build())
-                .build());
+            .setCount(likes)
+            .setTotal(likes)
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(userName)
+                .setNickname(userName)
+                .build())
+            .build());
+    }
+
+    public static TikTokLikeEvent of(User user, int likes) {
+        return new TikTokLikeEvent(WebcastLikeMessage.newBuilder()
+            .setCount(likes)
+            .setTotal(likes)
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(user.getName())
+                .setNickname(user.getProfileName())
+                .build())
+            .build());
     }
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokShareEvent.java

@@ -49,10 +49,19 @@ public class TikTokShareEvent extends TikTokHeaderEvent {
 
     public static TikTokShareEvent of(String userName, int shaders) {
         return new TikTokShareEvent(WebcastSocialMessage.newBuilder()
-                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
-                        .setUsername(userName)
-                        .setNickname(userName)
-                        .build())
-                .build(), shaders);
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(userName)
+                .setNickname(userName)
+                .build())
+            .build(), shaders);
+    }
+
+    public static TikTokShareEvent of(User user, int shaders) {
+        return new TikTokShareEvent(WebcastSocialMessage.newBuilder()
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setUsername(user.getName())
+                .setNickname(user.getProfileName())
+                .build())
+            .build(), shaders);
     }
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Team.java

@@ -23,6 +23,7 @@
 package io.github.jwdeveloper.tiktok.data.models.battles;
 
 import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.data.BattleUserInfo;
 import io.github.jwdeveloper.tiktok.messages.enums.BattleType;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicBattle;
 import lombok.Data;
@@ -72,12 +73,12 @@ public class Team {
         this.hosts = List.copyOf(hosts);
     }
 
-    public Team(WebcastLinkMicBattle.BattleUserInfo anchorInfo) {
+    public Team(BattleUserInfo anchorInfo) {
         this.hosts = List.of(new User(anchorInfo.getUser()));
         this.teamId = hosts.get(0).getId();
     }
 
-    public Team(WebcastLinkMicBattle.BattleUserInfo anchorInfo, WebcastLinkMicBattle.BattleComboInfo battleCombo) {
+    public Team(BattleUserInfo anchorInfo, WebcastLinkMicBattle.BattleComboInfo battleCombo) {
         this(anchorInfo);
         this.winStreak = (int) battleCombo.getComboCount();
     }

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/users/User.java

@@ -24,7 +24,7 @@ package io.github.jwdeveloper.tiktok.data.models.users;
 
 import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.badges.Badge;
-import io.github.jwdeveloper.tiktok.messages.data.BattleUserArmy;
+import io.github.jwdeveloper.tiktok.messages.data.*;
 import io.github.jwdeveloper.tiktok.messages.webcast.*;
 import lombok.*;
 
@@ -140,7 +140,7 @@ public class User {
         this(id, name, profileId, null, picture, 0, 0, List.of(Badge.empty()));
     }
 
-    public User(WebcastLinkMicBattle.BattleUserInfo.BattleBaseUserInfo host) {
+    public User(BattleUserInfo.BattleBaseUserInfo host) {
         this(host.getUserId(), host.getDisplayId(), host.getNickName(), Picture.map(host.getAvatarThumb()));
     }
 

API/src/main/java/io/github/jwdeveloper/tiktok/data/requests/LiveData.java

@@ -52,6 +52,7 @@ public class LiveData {
     public enum LiveStatus {
         HostNotFound,
         HostOnline,
+        HostPaused,
         HostOffline,
     }
 

API/src/main/java/io/github/jwdeveloper/tiktok/data/requests/LiveUserData.java

@@ -22,7 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.data.requests;
 
-import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
 import lombok.*;
 
 public class LiveUserData {
@@ -43,9 +43,7 @@ public class LiveUserData {
     public static class Response {
         private final String json;
         private final UserStatus userStatus;
-        private final String roomId;
-        private final long startTime;
-        private final User user;
+        private final LiveRoomInfo roomInfo;
 
         public boolean isLiveOnline() {
             return userStatus == LiveUserData.UserStatus.Live || userStatus == LiveUserData.UserStatus.LivePaused;

API/src/main/java/io/github/jwdeveloper/tiktok/data/settings/LiveClientSettings.java

@@ -89,6 +89,16 @@ public class LiveClientSettings {
     /** Throw an exception on 18+ Age Restriction */
     private boolean throwOnAgeRestriction;
 
+    /** Use Eulerstream.com websocket for events
+     * @apiNote Requires API Key
+     */
+    private boolean useEulerstreamWebsocket;
+
+    /** Use Eulerstream.com enterprise endpoints
+     * @apiNote Requires API Key with
+     */
+    private boolean useEulerstreamEnterprise;
+
     /**
 	 * Optional: Sometimes not every messages from chat are send to TikTokLiveJava to fix this issue you can set sessionId.
      * <p>This requires {@link #ttTargetIdc} also being set correctly for sessionid to be effective.

API/src/main/java/io/github/jwdeveloper/tiktok/data/settings/ProxyClientSettings.java

@@ -95,6 +95,9 @@ public class ProxyClientSettings implements Iterator<ProxyData>, Iterable<ProxyD
     public ProxyClientSettings clone() {
         ProxyClientSettings settings = new ProxyClientSettings();
         settings.setEnabled(enabled);
+        settings.setAutoDiscard(autoDiscard);
+        settings.setFallback(fallback);
+        settings.setAllowWebsocket(allowWebsocket);
         settings.setRotation(rotation);
         settings.setIndex(index);
         settings.setType(type);

API/src/main/java/io/github/jwdeveloper/tiktok/http/LiveHttpClient.java

@@ -26,6 +26,7 @@ import io.github.jwdeveloper.tiktok.data.requests.GiftsData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
+import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
 
 public interface LiveHttpClient
 {
@@ -64,4 +65,6 @@ public interface LiveHttpClient
     }
 
     LiveConnectionData.Response fetchLiveConnectionData(LiveConnectionData.Request request);
+
+    boolean sendChat(LiveRoomInfo roomInfo, String content, String sessionId, String ttTargetIdc);
 }

API/src/main/java/io/github/jwdeveloper/tiktok/live/LiveClient.java

@@ -24,6 +24,7 @@ package io.github.jwdeveloper.tiktok.live;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.listener.ListenersManager;
+import io.github.jwdeveloper.tiktok.websocket.LiveClientStopType;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
@@ -36,7 +37,6 @@ public interface LiveClient {
      */
     void connect();
 
-
     /**
      * Connects in asynchronous way
      * When connected Consumer returns instance of LiveClient
@@ -48,19 +48,25 @@ public interface LiveClient {
      */
     CompletableFuture<LiveClient> connectAsync();
 
-
     /**
      * Disconnects the connection.
+     * @param type {@code LiveClientStopType}
+     * @see LiveClientStopType
      */
-    void disconnect();
+    void disconnect(LiveClientStopType type);
 
+    /**
+     * Disconnects with {@link LiveClientStopType#NORMAL}
+     */
+    default void disconnect() {
+        disconnect(LiveClientStopType.NORMAL);
+    }
 
     /**
      * Use to manually invoke event
      */
     void publishEvent(TikTokEvent event);
 
-
     /**
      * @param webcastMessageName name of TikTok protocol-buffer message
      * @param payloadBase64      protocol-buffer message bytes payload
@@ -88,4 +94,20 @@ public interface LiveClient {
      * Logger
      */
     Logger getLogger();
+
+    /**
+     * Send a chat message to the connected room
+     * @return true if successful, otherwise false
+     * @apiNote This is known to return true on some sessionIds despite failing!
+     * <p>We cannot fix this as it is a TikTok issue, not a library issue.
+     */
+    boolean sendChat(String content);
+
+    /**
+     * Send a chat message to the connected room
+     * @return true if successful, otherwise false
+     * @apiNote This is known to return true on some sessionIds despite failing!
+     * <p>We cannot fix this as it is a TikTok issue, not a library issue.
+     */
+    boolean sendChat(String content, String sessionId, String ttTargetIdc);
 }

API/src/main/java/io/github/jwdeveloper/tiktok/live/LiveRoomInfo.java

@@ -49,5 +49,7 @@ public interface LiveRoomInfo
      String getTitle();
      User getHost();
      List<RankingUser> getUsersRanking();
+     String getLanguage();
      ConnectionState getConnectionState();
+     void copy(LiveRoomInfo roomInfo);
 }

API/src/main/java/io/github/jwdeveloper/tiktok/websocket/LiveClientStopType.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023-2024 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.websocket;
+
+public enum LiveClientStopType
+{
+    /**
+     * Initiates the websocket close handshake. This method does not block<br> In oder to make sure
+     * the connection is closed use {@link LiveClientStopType#CLOSE_BLOCKING}
+     */
+    NORMAL,
+    /**
+     * Same as {@link LiveClientStopType#NORMAL} but blocks until the websocket closed or failed to do so.<br>
+     *
+     * @apiNote Can throw {@link InterruptedException} when/if the threads get interrupted
+     */
+    CLOSE_BLOCKING,
+    /**
+     * This will close the connection immediately without a proper close handshake.
+     * The code and the message therefore won't be transferred over the wire also they will be forwarded to onClose/onWebsocketClose. */
+    DISCONNECT
+}

API/src/main/java/io/github/jwdeveloper/tiktok/websocket/LiveSocketClient.java

@@ -27,6 +27,6 @@ import io.github.jwdeveloper.tiktok.live.LiveClient;
 
 public interface LiveSocketClient {
     void start(LiveConnectionData.Response webcastResponse, LiveClient tikTokLiveClient);
-    void stop();
+    void stop(LiveClientStopType type);
     boolean isConnected();
 }

API/src/main/proto/data.proto

@@ -62,12 +62,11 @@ message Text {
     int32 type = 1;
     TextFormat format = 2;
     string stringValue = 11;
-    oneof textPieceType
-    {
-      TextPieceUser userValue = 21;
-      TextPieceGift giftValue = 22;
-    }
+    TextPieceUser userValue = 21;
+    TextPieceGift giftValue = 22;
+    TextPieceHeart heartValue = 23;
     TextPiecePatternRef patternRefValue = 24;
+    TextPieceImage imageValue = 25;
   }
 
   message TextFormat {
@@ -83,7 +82,7 @@ message Text {
 
   message TextPieceGift {
     int32 giftId = 1;
-    PatternRef nameRef = 2;
+    TextPiecePatternRef nameRef = 2;
     ShowType showType = 3; // Enum
     int64 colorId = 4;
   }
@@ -98,16 +97,19 @@ message Text {
     bool withColon = 2;
   }
 
-  message PatternRef {
-    string key = 1;
-    string default_pattern = 2;
-  }
-
   enum ShowType {
     SHOW_TYPE_NORMAL = 0;
     SHOW_TYPE_FADE_IN_OUT = 1;
   }
 
+  message TextPieceHeart {
+    string color = 1;
+  }
+
+  message TextPieceImage {
+    Image image_model = 1;
+  }
+
 }
 
 // @Image
@@ -151,7 +153,7 @@ message BadgeStruct {
   bool is_customized = 24;
 
   message CombineBadge {
-    int32 badge_display_type = 1;
+    BadgeDisplayType badge_display_type = 1;
     Image icon = 2;
     TextBadge text = 3;
     string str = 4;
@@ -2121,6 +2123,24 @@ message PublicAreaMessageCommon {
   }
 }
 
+message BattleUserInfo {
+  BattleBaseUserInfo user = 1;
+  repeated BattleRivalTag tags = 2;
+
+  message BattleBaseUserInfo {
+    int64 user_id = 1;
+    string nick_name = 2;
+    Image avatar_thumb = 3;
+    string display_id = 4;
+  }
+
+  message BattleRivalTag {
+    Image bg_image = 1;
+    Image icon_image = 2;
+    string content = 3;
+  }
+}
+
 message GiftModeMeta {
   int64 gift_id = 1;
   string gift_name_key = 2;

API/src/main/proto/enums.proto

@@ -820,4 +820,19 @@ enum BattleType {
 enum BattleInviteType {
   BATTLE_INVITE_TYPE_NORMAL = 0;
   BATTLE_INVITE_TYPE_AGAIN = 1;
+}
+
+enum BattleCardMsgType {
+  BATTLE_CARD_MSG_TYPE_UNKNOWN_CARD_ACTION = 0;
+  BATTLE_CARD_MSG_TYPE_CARD_OBTAIN_GUIDE = 1;
+  BATTLE_CARD_MSG_TYPE_USE_CRITICAL_STRIKE_CARD = 2;
+  BATTLE_CARD_MSG_TYPE_USE_SMOKE_CARD = 3;
+  BATTLE_CARD_MSG_TYPE_AWARD_CARD_NOTICE = 4;
+  BATTLE_CARD_MSG_TYPE_USE_EXTRA_TIME_CARD = 5;
+  BATTLE_CARD_MSG_TYPE_USE_SPECIAL_EFFECT_CARD = 6;
+  BATTLE_CARD_MSG_TYPE_USE_POTION_CARD = 7;
+  BATTLE_CARD_MSG_TYPE_USE_WAVE_CARD = 8;
+  BATTLE_CARD_MSG_TYPE_SPECIAL_EFFECT_NOTICE = 9;
+  BATTLE_CARD_MSG_TYPE_USE_TOP_2_CARD = 10;
+  BATTLE_CARD_MSG_TYPE_USE_TOP_3_CARD = 11;
 }

API/src/main/proto/webcast.proto

@@ -1219,24 +1219,6 @@ message WebcastLinkMicBattle {
 //    BattleUserInfo user_info = 2;
 //  }
 
-  message BattleUserInfo {
-    BattleBaseUserInfo user = 1;
-    repeated BattleRivalTag tags = 2;
-
-    message BattleBaseUserInfo {
-      int64 user_id = 1;
-      string nick_name = 2;
-      Image avatar_thumb = 3;
-      string display_id = 4;
-    }
-
-    message BattleRivalTag {
-      Image bg_image = 1;
-      Image icon_image = 2;
-      string content = 3;
-    }
-  }
-
   message BattleABTestSetting {
     int64 uid = 1;
     BattleABTestList ab_test_list = 2;
@@ -1471,4 +1453,139 @@ message RoomVerifyMessage {
   string content = 3;
   int64 noticeType = 4;
   bool closeRoom = 5;
+}
+message WebcastLinkMicBattleItemCard {
+  CommonMessageData common = 1;
+  int64 battle_id = 2;
+  BattleCardMsgType msg_type = 3;
+  CardObtainGuide card_obtain_guide = 4;
+  UseCriticalStrikeCard use_critical_strike_card = 5;
+  UseSmokeCard use_smoke_card = 6;
+  AwardCardNotice award_card_notice = 7;
+  UseExtraTimeCard use_extra_time_card = 8;
+  UseSpecialEffectCard use_special_effect_card = 9;
+  UsePotionCard use_potion_card = 10;
+  UseWaveCard use_wave_card = 11;
+  SpecialEffectNotice special_effect_notice = 12;
+  UseTop2Card use_top2_card = 13;
+  UseTop3Card use_top3_card = 14;
+
+  message CardObtainGuide {
+    int32 not_in_use = 1;
+  }
+
+  message UseCriticalStrikeCard {
+    CriticalStrikeCardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+
+    message CriticalStrikeCardInfo {
+      string card_name_key = 1;
+      Image card_image = 2;
+      int64 send_time_sec = 3;
+      BattleUserInfo send_user = 4;
+      int64 effect_last_duration = 5;
+      int64 critical_strike_rate_low = 6;
+      int64 critical_strike_rate_high = 7;
+      int64 multiple = 8;
+      string gift_name_key = 9;
+      string rule_url = 10;
+      int64 effect_time_sec = 11;
+      int64 to_anchor_id = 12;
+      string to_anchor_id_str = 13;
+    }
+  }
+
+  message UseSmokeCard {
+    CommonCardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+  }
+
+  message AwardCardNotice {
+    Text display_content = 1;
+    repeated BattleUserInfo awarded_users = 2;
+  }
+
+  message UseExtraTimeCard {
+    ExtraTimeCardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+
+    message ExtraTimeCardInfo {
+      string card_name_key = 1;
+      Image card_image = 2;
+      int64 send_time_sec = 3;
+      BattleUserInfo send_user = 4;
+      int64 effect_last_duration = 5;
+      string rule_url = 6;
+      int64 effect_time_sec = 7;
+      int64 to_anchor_id = 8;
+      int64 extra_duration_sec = 9;
+      string to_anchor_id_str = 10;
+    }
+  }
+
+  message UseSpecialEffectCard {
+    CommonCardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+    repeated AnchorPair affected_anchor_pairs = 4;
+  }
+
+  message AnchorPair {
+    int64 source_anchor_id = 1;
+    int64 target_anchor_id = 2;
+  }
+
+  message UsePotionCard {
+    CommonCardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+  }
+
+  message UseWaveCard {
+    CommonCardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+  }
+
+  message CommonCardInfo {
+    string card_name_key = 1;
+    Image card_image = 2;
+    int64 send_time_sec = 3;
+    BattleUserInfo send_user = 4;
+    int64 effect_last_duration = 5;
+    string rule_url = 6;
+    int64 effect_time_sec = 7;
+    int64 to_anchor_id = 8;
+    string to_anchor_id_str = 9;
+  }
+
+  message SpecialEffectNotice {
+    int64 score = 1;
+    int64 from_user_id = 2;
+    int64 to_anchor_id = 3;
+    repeated AnchorPair affected_anchor_pairs = 4;
+  }
+
+  message UseTop2Card {
+    Top2CardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+
+    message Top2CardInfo {
+      CommonCardInfo common = 1;
+    }
+  }
+
+  message UseTop3Card {
+    Top3CardInfo card_info = 1;
+    int64 anchor_id = 2;
+    Text display_content = 3;
+
+    message Top3CardInfo {
+      CommonCardInfo common = 1;
+    }
+  }
 }

Client/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.10.4-Release</version>
+        <version>1.11.9-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -23,6 +23,7 @@
 package io.github.jwdeveloper.tiktok;
 
 import com.google.protobuf.ByteString;
+import io.github.jwdeveloper.tiktok.common.AsyncHandler;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.control.*;
@@ -35,11 +36,11 @@ import io.github.jwdeveloper.tiktok.listener.ListenersManager;
 import io.github.jwdeveloper.tiktok.live.*;
 import io.github.jwdeveloper.tiktok.messages.webcast.ProtoMessageFetchResult;
 import io.github.jwdeveloper.tiktok.models.ConnectionState;
-import io.github.jwdeveloper.tiktok.websocket.LiveSocketClient;
+import io.github.jwdeveloper.tiktok.websocket.*;
 import lombok.Getter;
 
 import java.util.Base64;
-import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.*;
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
@@ -79,19 +80,21 @@ public class TikTokLiveClient implements LiveClient
 
     public void connect() {
         try {
-            tryConnect();
+            if (clientSettings.isUseEulerstreamWebsocket())
+                tryEulerConnect();
+            else
+                tryConnect();
         } catch (TikTokLiveException e) {
             setState(ConnectionState.DISCONNECTED);
             tikTokEventHandler.publish(this, new TikTokErrorEvent(e));
-            tikTokEventHandler.publish(this, new TikTokDisconnectedEvent("Exception: "+e.getMessage()));
+            tikTokEventHandler.publish(this, new TikTokDisconnectedEvent("Exception: " + e.getMessage()));
 
             if (e instanceof TikTokLiveOfflineHostException && clientSettings.isRetryOnConnectionFailure()) {
-                try {
-                    Thread.sleep(clientSettings.getRetryConnectionTimeout().toMillis());
-                } catch (Exception ignored) {}
-                logger.info("Reconnecting");
-                tikTokEventHandler.publish(this, new TikTokReconnectingEvent());
-                this.connect();
+                AsyncHandler.getReconnectScheduler().schedule(() -> {
+                    logger.info("Reconnecting");
+                    tikTokEventHandler.publish(this, new TikTokReconnectingEvent());
+                    this.connect();
+                }, clientSettings.getRetryConnectionTimeout().toMillis(), TimeUnit.MILLISECONDS);
             }
             throw e;
         } catch (Exception e) {
@@ -101,6 +104,17 @@ public class TikTokLiveClient implements LiveClient
         }
     }
 
+    private void tryEulerConnect() {
+        if (!roomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
+            throw new TikTokLiveException("Already connected");
+        }
+
+        setState(ConnectionState.CONNECTING);
+        tikTokEventHandler.publish(this, new TikTokConnectingEvent());
+        webSocketClient.start(null, this);
+        setState(ConnectionState.CONNECTED);
+    }
+
     public void tryConnect() {
         if (!roomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
             throw new TikTokLiveException("Already connected");
@@ -110,8 +124,6 @@ public class TikTokLiveClient implements LiveClient
         tikTokEventHandler.publish(this, new TikTokConnectingEvent());
         var userDataRequest = new LiveUserData.Request(roomInfo.getHostName());
         var userData = httpClient.fetchLiveUserData(userDataRequest);
-        roomInfo.setStartTime(userData.getStartTime());
-        roomInfo.setRoomId(userData.getRoomId());
 
         if (userData.getUserStatus() == LiveUserData.UserStatus.Offline)
             throw new TikTokLiveOfflineHostException("User is offline: " + roomInfo.getHostName(), userData, null);
@@ -119,7 +131,9 @@ public class TikTokLiveClient implements LiveClient
         if (userData.getUserStatus() == LiveUserData.UserStatus.NotFound)
             throw new TikTokLiveUnknownHostException("User not found: " + roomInfo.getHostName(), userData, null);
 
-        var liveDataRequest = new LiveData.Request(userData.getRoomId());
+        roomInfo.copy(userData.getRoomInfo());
+
+        var liveDataRequest = new LiveData.Request(userData.getRoomInfo().getRoomId());
         var liveData = httpClient.fetchLiveData(liveDataRequest);
 
         if (liveData.isAgeRestricted() && clientSettings.isThrowOnAgeRestriction())
@@ -143,9 +157,9 @@ public class TikTokLiveClient implements LiveClient
             throw new TikTokLivePreConnectionException(preconnectEvent);
 
         if (clientSettings.isFetchGifts())
-            giftManager.attachGiftsList(httpClient.fetchRoomGiftsData(userData.getRoomId()).getGifts());
+            giftManager.attachGiftsList(httpClient.fetchRoomGiftsData(userData.getRoomInfo().getRoomId()).getGifts());
 
-        var liveConnectionRequest = new LiveConnectionData.Request(userData.getRoomId());
+        var liveConnectionRequest = new LiveConnectionData.Request(userData.getRoomInfo().getRoomId());
         var liveConnectionData = httpClient.fetchLiveConnectionData(liveConnectionRequest);
         webSocketClient.start(liveConnectionData, this);
 
@@ -153,9 +167,9 @@ public class TikTokLiveClient implements LiveClient
         tikTokEventHandler.publish(this, new TikTokRoomInfoEvent(roomInfo));
     }
 
-    public void disconnect() {
+    public void disconnect(LiveClientStopType type) {
         if (webSocketClient.isConnected())
-            webSocketClient.stop();
+            webSocketClient.stop(type);
 		if (!roomInfo.hasConnectionState(ConnectionState.DISCONNECTED))
 			setState(ConnectionState.DISCONNECTED);
 	}
@@ -183,6 +197,16 @@ public class TikTokLiveClient implements LiveClient
         messageHandler.handleSingleMessage(this, message);
     }
 
+    @Override
+    public boolean sendChat(String content) {
+        return sendChat(content, clientSettings.getSessionId(), clientSettings.getTtTargetIdc());
+    }
+
+    @Override
+    public boolean sendChat(String content, String sessionId, String ttTargetIdc) {
+        return httpClient.sendChat(roomInfo, content, sessionId, ttTargetIdc);
+    }
+
     public void connectAsync(Consumer<LiveClient> onConnection) {
         connectAsync().thenAccept(onConnection);
     }

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

@@ -42,6 +42,7 @@ import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokGiftEventHandler;
 import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokRoomInfoEventHandler;
 import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokSocialMediaEventHandler;
 import io.github.jwdeveloper.tiktok.websocket.*;
+import io.github.jwdeveloper.tiktok.websocket.euler.TikTokWebSocketEulerClient;
 
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
@@ -137,7 +138,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
             dependance.registerSingleton(LiveSocketClient.class, TikTokWebSocketOfflineClient.class);
             dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpOfflineClient.class);
         } else {
-            dependance.registerSingleton(LiveSocketClient.class, TikTokWebSocketClient.class);
+            dependance.registerSingleton(LiveSocketClient.class, clientSettings.isUseEulerstreamWebsocket() ? TikTokWebSocketEulerClient.class : TikTokWebSocketClient.class);
             dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpClient.class);
         }
 

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

@@ -22,6 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok;
 
+import com.google.gson.JsonObject;
 import com.google.protobuf.InvalidProtocolBufferException;
 import io.github.jwdeveloper.dependance.injector.api.annotations.Inject;
 import io.github.jwdeveloper.tiktok.common.*;
@@ -30,9 +31,10 @@ import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
 import io.github.jwdeveloper.tiktok.exceptions.*;
 import io.github.jwdeveloper.tiktok.http.*;
 import io.github.jwdeveloper.tiktok.http.mappers.*;
+import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
 import io.github.jwdeveloper.tiktok.messages.webcast.ProtoMessageFetchResult;
 
-import java.net.http.HttpResponse;
+import java.net.http.*;
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
@@ -42,16 +44,17 @@ public class TikTokLiveHttpClient implements LiveHttpClient
 	 * <a href="https://github-wiki-see.page/m/isaackogan/TikTokLive/wiki/All-About-Signatures">Signing API by Isaac Kogan</a>
 	 */
     private static final String TIKTOK_SIGN_API = "https://tiktok.eulerstream.com/webcast/fetch";
+    private static final String TIKTOK_CHAT_URL = "https://tiktok.eulerstream.com/webcast/chat";
+    private static final String TIKTOK_SIGN_ENTERPRISE_API = "https://tiktok.enterprise.eulerstream.com/webcast/fetch";
+    private static final String TIKTOK_CHAT_ENTERPRISE_URL = "https://tiktok.enterprise.eulerstream.com/webcast/chat";
     private static final String TIKTOK_URL_WEB = "https://www.tiktok.com/";
     private static final String TIKTOK_URL_WEBCAST = "https://webcast.tiktok.com/webcast/";
-    public static final String TIKTOK_ROOM_GIFTS_URL = TIKTOK_URL_WEBCAST+"gift/list/";
+    private static final String TIKTOK_ROOM_GIFTS_URL = TIKTOK_URL_WEBCAST+"gift/list/";
+    private static final String TIKTOK_ROOM_INFO_URL = TIKTOK_URL_WEBCAST + "room/info";
     public static final int TIKTOK_AGE_RESTRICTED_CODE = 4003110;
 
     private final HttpClientFactory httpFactory;
     private final LiveClientSettings clientSettings;
-    private final LiveUserDataMapper liveUserDataMapper;
-    private final LiveDataMapper liveDataMapper;
-    private final GiftsDataMapper giftsDataMapper;
     private final Logger logger;
 
     @Inject
@@ -59,9 +62,6 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         this.httpFactory = factory;
         this.clientSettings = factory.getLiveClientSettings();
         this.logger = LoggerFactory.create("HttpClient-"+hashCode(), clientSettings);
-        liveUserDataMapper = new LiveUserDataMapper();
-        liveDataMapper = new LiveDataMapper();
-        giftsDataMapper = new GiftsDataMapper();
     }
 
     public TikTokLiveHttpClient(Consumer<LiveClientSettings> consumer) {
@@ -91,7 +91,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
             throw new TikTokLiveRequestException("Unable to fetch gifts information's - "+result);
 
         var json = result.getContent();
-        return giftsDataMapper.mapRoom(json);
+        return GiftsDataMapper.mapRoom(json);
     }
 
     @Override
@@ -121,7 +121,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
             throw new TikTokLiveRequestException("Unable to get information's about user - "+result);
 
         var json = result.getContent();
-        return liveUserDataMapper.map(json, logger);
+        return LiveUserDataMapper.map(json, logger);
     }
 
     @Override
@@ -138,8 +138,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
     }
 
     public LiveData.Response getLiveData(LiveData.Request request) {
-        var url = TIKTOK_URL_WEBCAST + "room/info";
-        var result = httpFactory.client(url)
+        var result = httpFactory.client(TIKTOK_ROOM_INFO_URL)
             .withParam("room_id", request.getRoomId())
             .withCookie("sessionid", clientSettings.getSessionId())
             .withCookie("tt-target-idc", clientSettings.getTtTargetIdc())
@@ -150,7 +149,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
             throw new TikTokLiveRequestException("Unable to get info about live room - "+result);
 
         var json = result.getContent();
-        return liveDataMapper.map(json);
+        return LiveDataMapper.map(json);
     }
 
     @Override
@@ -182,6 +181,33 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         }
     }
 
+    @Override
+    public boolean sendChat(LiveRoomInfo roomInfo, String content, String sessionId, String ttTargetIdc) {
+        var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
+        if (proxyClientSettings.isEnabled()) {
+            while (proxyClientSettings.hasNext()) {
+                try {
+                    return requestSendChat(roomInfo, content, sessionId, ttTargetIdc);
+                } catch (TikTokProxyRequestException ignored) {}
+            }
+        }
+        return requestSendChat(roomInfo, content, sessionId, ttTargetIdc);
+    }
+
+    public boolean requestSendChat(LiveRoomInfo roomInfo, String content, String sessionId, String ttTargetIdc) {
+        JsonObject body = new JsonObject();
+        body.addProperty("content", content);
+        body.addProperty("sessionId", sessionId);
+        body.addProperty("ttTargetIdc", ttTargetIdc);
+        body.addProperty("roomId", roomInfo.getRoomId());
+        HttpClientBuilder builder = httpFactory.client(clientSettings.isUseEulerstreamEnterprise() ? TIKTOK_CHAT_ENTERPRISE_URL : TIKTOK_CHAT_URL)
+            .withHeader("Content-Type", "application/json");
+        if (clientSettings.getApiKey() != null)
+            builder.withHeader("x-api-key", clientSettings.getApiKey());
+        var result = builder.withBody(HttpRequest.BodyPublishers.ofString(body.toString())).build().toJsonResponse();
+        return result.isSuccess();
+    }
+
     protected ActionResult<HttpResponse<byte[]>> getStartingPayload(LiveConnectionData.Request request) {
         var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
         if (proxyClientSettings.isEnabled()) {
@@ -195,12 +221,14 @@ public class TikTokLiveHttpClient implements LiveHttpClient
     }
 
     protected ActionResult<HttpResponse<byte[]>> getByteResponse(String room_id) {
-        HttpClientBuilder builder = httpFactory.client(TIKTOK_SIGN_API)
+        HttpClientBuilder builder = httpFactory.client(clientSettings.isUseEulerstreamEnterprise() ? TIKTOK_SIGN_ENTERPRISE_API : TIKTOK_SIGN_API)
             .withParam("client", "ttlive-java")
             .withParam("room_id", room_id);
 
+        if (clientSettings.getSessionId() != null) // Allows receiving of all comments and Subscribe Events
+            builder.withParam("session_id", clientSettings.getSessionId());
         if (clientSettings.getApiKey() != null)
-            builder.withParam("apiKey", clientSettings.getApiKey());
+            builder.withHeader("x-api-key", clientSettings.getApiKey());
 
         var result = builder.build().toHttpResponse(HttpResponse.BodyHandlers.ofByteArray());
 

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

@@ -26,6 +26,7 @@ import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.data.requests.*;
 import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
+import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
 import io.github.jwdeveloper.tiktok.messages.webcast.ProtoMessageFetchResult;
 
 import java.net.URI;
@@ -39,26 +40,32 @@ public class TikTokLiveHttpOfflineClient implements LiveHttpClient {
 
     @Override
     public LiveUserData.Response fetchLiveUserData(LiveUserData.Request request) {
-        return new LiveUserData.Response("", LiveUserData.UserStatus.Live, "offline_room_id", 0, null);
+        return new LiveUserData.Response("", LiveUserData.UserStatus.Live, null);
     }
 
     @Override
     public LiveData.Response fetchLiveData(LiveData.Request request) {
         return new LiveData.Response("",
-                LiveData.LiveStatus.HostOnline,
-                "offline live",
-                0,
-                0,
-                0,
-                false,
-                new User(0L, "offline user", new Picture("")),
-                LiveData.LiveType.SOLO);
+            LiveData.LiveStatus.HostOnline,
+            "offline live",
+            0,
+            0,
+            0,
+            false,
+            new User(0L, "offline user", new Picture("")),
+            LiveData.LiveType.SOLO);
     }
 
     @Override
     public LiveConnectionData.Response fetchLiveConnectionData(LiveConnectionData.Request request) {
         return new LiveConnectionData.Response("",
-                URI.create("https://example.live"),
-                ProtoMessageFetchResult.newBuilder().build());
+            URI.create("https://example.live"),
+            ProtoMessageFetchResult.newBuilder().build());
+    }
+
+    @Override
+    public boolean sendChat(LiveRoomInfo roomInfo, String content, String sessionId, String ttTargetIdc) {
+        // DO NOTHING
+        return false;
     }
 }

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

@@ -32,37 +32,44 @@ import java.util.LinkedList;
 import java.util.List;
 
 @Data
-public class TikTokRoomInfo implements LiveRoomInfo {
-    private String roomId;
+public class TikTokRoomInfo implements LiveRoomInfo
+{
+	private String roomId;
+	private int likesCount;
+	private int viewersCount;
+	private int totalViewersCount;
+	private long startTime;
+	private boolean ageRestricted;
+	private User host;
+	private List<RankingUser> usersRanking = new LinkedList<>();
+	private String hostName;
+	private String title;
+	private String language = "en";
+	private ConnectionState connectionState = ConnectionState.DISCONNECTED;
 
-    private int likesCount;
+	public boolean hasConnectionState(ConnectionState state) {
+		return connectionState == state;
+	}
 
-    private int viewersCount;
+	public void updateRanking(List<RankingUser> rankingUsers) {
+		usersRanking.clear();
+		usersRanking.addAll(rankingUsers);
+	}
 
-    private int totalViewersCount;
-
-    private long startTime;
-
-    private boolean ageRestricted;
-
-    private User host;
-
-    private List<RankingUser> usersRanking = new LinkedList<>();
-
-    private String hostName;
-
-    private String title;
-
-    private String language = "en";
-
-    private ConnectionState connectionState = ConnectionState.DISCONNECTED;
-
-    public boolean hasConnectionState(ConnectionState state) {
-        return connectionState == state;
-    }
-
-    public void updateRanking(List<RankingUser> rankingUsers) {
-        usersRanking.clear();
-        usersRanking.addAll(rankingUsers);
-    }
+	@Override
+	public void copy(LiveRoomInfo roomInfo) {
+		if (roomInfo == null) return;
+		this.roomId = roomInfo.getRoomId();
+		this.likesCount = roomInfo.getLikesCount();
+		this.viewersCount = roomInfo.getViewersCount();
+		this.totalViewersCount = roomInfo.getTotalViewersCount();
+		this.startTime = roomInfo.getStartTime();
+		this.ageRestricted = roomInfo.isAgeRestricted();
+		this.host = roomInfo.getHost();
+		this.usersRanking = roomInfo.getUsersRanking();
+		this.hostName = roomInfo.getHostName();
+		this.title = roomInfo.getTitle();
+		this.language = roomInfo.getLanguage();
+		// this.connectionState = roomInfo.getConnectionState(); // This should not be copied - Controlled elsewhere!
+	}
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/common/AsyncHandler.java

@@ -0,0 +1,22 @@
+package io.github.jwdeveloper.tiktok.common;
+
+import lombok.Getter;
+
+import java.util.concurrent.*;
+
+public class AsyncHandler
+{
+	@Getter
+	private static final ScheduledExecutorService heartBeatScheduler = Executors.newScheduledThreadPool(1, r -> {
+		Thread t = new Thread(r, "heartbeat-pool");
+		t.setDaemon(true);
+		return t;
+	});
+
+	@Getter
+	private static final ScheduledExecutorService reconnectScheduler = Executors.newScheduledThreadPool(0, r -> {
+		Thread t = new Thread(r, "reconnect-pool");
+		t.setDaemon(true);
+		return t;
+	});
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpClient.java

@@ -40,11 +40,12 @@ public class HttpClient {
 
     protected final HttpClientSettings httpClientSettings;
     protected final String url;
+    protected final HttpRequest.BodyPublisher bodyPublisher;
     private final Pattern pattern = Pattern.compile("charset=(.*?)(?=&|$)");
 
     public <T> ActionResult<HttpResponse<T>> toHttpResponse(HttpResponse.BodyHandler<T> handler) {
         var client = prepareClient();
-        var request = prepareGetRequest();
+        var request = prepareRequest();
         try {
             var response = client.send(request, handler);
             var result = ActionResult.of(response);
@@ -68,7 +69,7 @@ public class HttpClient {
         }
     }
 
-    public <T> ActionResult<T> toResponse(HttpResponse.BodyHandler<T> handler) {
+    protected <T> ActionResult<T> toResponse(HttpResponse.BodyHandler<T> handler) {
         return toHttpResponse(handler).map(HttpResponse::body);
     }
 
@@ -99,8 +100,13 @@ public class HttpClient {
         return URI.create(stringUrl);
     }
 
-    protected HttpRequest prepareGetRequest() {
-        var requestBuilder = HttpRequest.newBuilder().GET();
+    /**
+     * @return {@link HttpRequest} with default GET, otherwise POST if {@link #bodyPublisher} is not null
+     */
+    protected HttpRequest prepareRequest() {
+        var requestBuilder = HttpRequest.newBuilder();
+        if (bodyPublisher != null)
+            requestBuilder.POST(bodyPublisher);
         requestBuilder.uri(toUri());
         requestBuilder.timeout(httpClientSettings.getTimeout());
         if (!httpClientSettings.getCookies().isEmpty()) {
@@ -124,12 +130,10 @@ public class HttpClient {
     }
 
     protected String prepareUrlWithParameters(String url, Map<String, Object> parameters) {
-        if (parameters.isEmpty()) {
-            return url;
-        }
+        if (parameters.isEmpty())
+			return url;
 
-        return url + "?" + parameters.entrySet().stream().map(entry ->
-        {
+        return url + "?" + parameters.entrySet().stream().map(entry -> {
             var encodedKey = URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8);
             var encodedValue = URLEncoder.encode(entry.getValue().toString(), StandardCharsets.UTF_8);
             return encodedKey + "=" + encodedValue;

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpClientBuilder.java

@@ -24,6 +24,7 @@ package io.github.jwdeveloper.tiktok.http;
 
 import io.github.jwdeveloper.tiktok.data.settings.HttpClientSettings;
 
+import java.net.http.HttpRequest;
 import java.util.Map;
 import java.util.function.Consumer;
 
@@ -31,6 +32,7 @@ public class HttpClientBuilder {
 
     private final HttpClientSettings httpClientSettings;
     private String url;
+    private HttpRequest.BodyPublisher bodyPublisher;
 
     public HttpClientBuilder(String url, HttpClientSettings httpClientSettings) {
         this.httpClientSettings = httpClientSettings;
@@ -78,10 +80,15 @@ public class HttpClientBuilder {
         return this;
     }
 
+    public HttpClientBuilder withBody(HttpRequest.BodyPublisher bodyPublisher) {
+        this.bodyPublisher = bodyPublisher;
+        return this;
+    }
+
     public HttpClient build() {
         var proxyClientSettings = httpClientSettings.getProxyClientSettings();
         if (proxyClientSettings.isEnabled() && proxyClientSettings.hasNext())
-            return new HttpProxyClient(httpClientSettings, url);
-        return new HttpClient(httpClientSettings, url);
+            return new HttpProxyClient(httpClientSettings, url, bodyPublisher);
+        return new HttpClient(httpClientSettings, url, bodyPublisher);
     }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/http/HttpProxyClient.java

@@ -31,28 +31,30 @@ import java.io.IOException;
 import java.net.*;
 import java.net.http.*;
 import java.net.http.HttpResponse.ResponseInfo;
+import java.nio.ByteBuffer;
 import java.security.*;
 import java.security.cert.X509Certificate;
 import java.util.*;
+import java.util.concurrent.Flow;
 import java.util.stream.Collectors;
 
 public class HttpProxyClient extends HttpClient {
 
 	private final ProxyClientSettings proxySettings;
 
-	public HttpProxyClient(HttpClientSettings httpClientSettings, String url) {
-		super(httpClientSettings, url);
+	public HttpProxyClient(HttpClientSettings httpClientSettings, String url, HttpRequest.BodyPublisher bodyPublisher) {
+		super(httpClientSettings, url, bodyPublisher);
 		this.proxySettings = httpClientSettings.getProxyClientSettings();
 	}
 
-	public ActionResult<HttpResponse<byte[]>> toResponse() {
+	public <T> ActionResult<HttpResponse<T>> toHttpResponse(HttpResponse.BodyHandler<T> handler) {
 		return switch (proxySettings.getType()) {
-			case HTTP, DIRECT -> handleHttpProxyRequest();
-			default -> handleSocksProxyRequest();
+			case HTTP, DIRECT -> handleHttpProxyRequest(handler);
+			default -> handleSocksProxyRequest(handler);
 		};
 	}
 
-	public ActionResult<HttpResponse<byte[]>> handleHttpProxyRequest() {
+	public <T> ActionResult<HttpResponse<T>> handleHttpProxyRequest(HttpResponse.BodyHandler<T> handler) {
 		var builder = java.net.http.HttpClient.newBuilder()
 			.followRedirects(java.net.http.HttpClient.Redirect.NORMAL)
 			.cookieHandler(new CookieManager())
@@ -65,9 +67,9 @@ public class HttpProxyClient extends HttpClient {
 
 				httpClientSettings.getOnClientCreating().accept(builder);
 				var client = builder.build();
-				var request = prepareGetRequest();
+				var request = prepareRequest();
 
-				var response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
+				var response = client.send(request, handler);
 				if (response.statusCode() != 200)
 					continue;
 				return ActionResult.success(response);
@@ -77,7 +79,7 @@ public class HttpProxyClient extends HttpClient {
 				throw new TikTokProxyRequestException(e);
 			} catch (IOException e) {
 				if (e.getMessage().contains("503") && proxySettings.isFallback()) // Indicates proxy protocol is not supported
-					return super.toHttpResponse(HttpResponse.BodyHandlers.ofByteArray());
+					return super.toHttpResponse(handler);
 				throw new TikTokProxyRequestException(e);
 			} catch (Exception e) {
 				throw new TikTokLiveRequestException(e);
@@ -86,7 +88,7 @@ public class HttpProxyClient extends HttpClient {
 		throw new TikTokLiveRequestException("No more proxies available!");
 	}
 
-	private ActionResult<HttpResponse<byte[]>> handleSocksProxyRequest() {
+	private <T> ActionResult<HttpResponse<T>> handleSocksProxyRequest(HttpResponse.BodyHandler<T> handler) {
 		try {
 			SSLContext sc = SSLContext.getInstance("SSL");
 			sc.init(null, new TrustManager[]{ new X509TrustManager() {
@@ -95,7 +97,8 @@ public class HttpProxyClient extends HttpClient {
 				public X509Certificate[] getAcceptedIssuers() { return null; }
 			}}, null);
 
-			URL url = toUri().toURL();
+			URI uri = toUri();
+			URL url = uri.toURL();
 
 			if (proxySettings.hasNext()) {
 				try {
@@ -117,12 +120,22 @@ public class HttpProxyClient extends HttpClient {
 
 					var responseInfo = createResponseInfo(socksConnection.getResponseCode(), headers);
 
-					var response = createHttpResponse(body, toUri(), responseInfo);
+					HttpResponse.BodySubscriber<T> subscriber = handler.apply(responseInfo);
+
+					subscriber.onSubscribe(new Flow.Subscription() {
+						@Override public void request(long n) {}
+						@Override public void cancel() {}
+					});
+
+					subscriber.onNext(List.of(ByteBuffer.wrap(body)));
+					subscriber.onComplete();
+
+					var response = createHttpResponse(subscriber.getBody().toCompletableFuture().join(), uri, responseInfo);
 
 					return ActionResult.success(response);
 				} catch (IOException e) {
 					if (e.getMessage().contains("503") && proxySettings.isFallback()) // Indicates proxy protocol is not supported
-						return super.toHttpResponse(HttpResponse.BodyHandlers.ofByteArray());
+						return super.toHttpResponse(handler);
 					if (proxySettings.isAutoDiscard())
 						proxySettings.remove();
 					throw new TikTokProxyRequestException(e);
@@ -160,7 +173,7 @@ public class HttpProxyClient extends HttpClient {
 		};
 	}
 
-	private HttpResponse<byte[]> createHttpResponse(byte[] body,
+	private <T> HttpResponse<T> createHttpResponse(T body,
 												   URI uri,
 												   ResponseInfo info) {
 		return new HttpResponse<>()
@@ -176,7 +189,7 @@ public class HttpProxyClient extends HttpClient {
 			}
 
 			@Override
-			public Optional<HttpResponse<byte[]>> previousResponse() {
+			public Optional<HttpResponse<T>> previousResponse() {
 				return Optional.empty();
 			}
 
@@ -186,7 +199,7 @@ public class HttpProxyClient extends HttpClient {
 			}
 
 			@Override
-			public byte[] body() {
+			public T body() {
 				return body;
 			}
 

Client/src/main/java/io/github/jwdeveloper/tiktok/http/mappers/GiftsDataMapper.java

@@ -32,7 +32,7 @@ import java.util.List;
 
 public class GiftsDataMapper {
 
-    public GiftsData.Response map(String json) {
+    public static GiftsData.Response map(String json) {
         var parsedJson = JsonParser.parseString(json);
         var jsonObject = parsedJson.getAsJsonObject();
         var gifts = jsonObject.entrySet()
@@ -43,7 +43,7 @@ public class GiftsDataMapper {
         return new GiftsData.Response(json, gifts);
     }
 
-    private Gift mapSingleGift(JsonElement jsonElement) {
+    private static Gift mapSingleGift(JsonElement jsonElement) {
         var jsonObject = jsonElement.getAsJsonObject();
 
         var id = jsonObject.get("id").getAsInt();
@@ -53,7 +53,7 @@ public class GiftsDataMapper {
         return new Gift(id, name, diamondCost, new Picture(image), jsonObject);
     }
 
-    public GiftsData.Response mapRoom(String json) {
+    public static GiftsData.Response mapRoom(String json) {
         var parsedJson = JsonParser.parseString(json);
         var jsonObject = parsedJson.getAsJsonObject();
         if (jsonObject.get("data") instanceof JsonObject data && data.get("gifts") instanceof JsonArray giftArray) {
@@ -69,7 +69,7 @@ public class GiftsDataMapper {
         return new GiftsData.Response("", List.of());
     }
 
-    private Gift mapSingleRoomGift(JsonElement jsonElement) {
+    private static Gift mapSingleRoomGift(JsonElement jsonElement) {
         var jsonObject = jsonElement.getAsJsonObject();
 
         var id = jsonObject.get("id").getAsInt();

Client/src/main/java/io/github/jwdeveloper/tiktok/http/mappers/LiveDataMapper.java

@@ -41,7 +41,7 @@ public class LiveDataMapper {
      * 3 - ?
      * 4 - Offline
      */
-    public LiveData.Response map(String json) {
+    public static LiveData.Response map(String json) {
         var response = new LiveData.Response();
 
         response.setJson(json);
@@ -61,6 +61,7 @@ public class LiveDataMapper {
             var statusId = status.getAsInt();
             var statusValue = switch (statusId) {
                 case 2 -> LiveData.LiveStatus.HostOnline;
+                case 3 -> LiveData.LiveStatus.HostPaused;
                 case 4 -> LiveData.LiveStatus.HostOffline;
                 default -> LiveData.LiveStatus.HostNotFound;
             };
@@ -127,7 +128,7 @@ public class LiveDataMapper {
         return response;
     }
 
-    public User getUser(JsonObject jsonElement) {
+    public static User getUser(JsonObject jsonElement) {
         var id = jsonElement.get("id").getAsLong();
         var name = jsonElement.get("display_id").getAsString();
         var profileName = jsonElement.get("nickname").getAsString();

Client/src/main/java/io/github/jwdeveloper/tiktok/http/mappers/LiveUserDataMapper.java

@@ -23,17 +23,18 @@
 package io.github.jwdeveloper.tiktok.http.mappers;
 
 import com.google.gson.*;
+import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 
-import java.util.List;
+import java.util.*;
 import java.util.logging.Logger;
 
 public class LiveUserDataMapper
 {
-    public LiveUserData.Response map(String json, Logger logger) {
+    public static LiveUserData.Response map(String json, Logger logger) {
         try {
             var jsonObject = JsonParser.parseString(json).getAsJsonObject();
 
@@ -43,14 +44,14 @@ public class LiveUserDataMapper
                 throw new TikTokLiveRequestException("fetchRoomIdFromTiktokApi -> Unable to fetch roomID, contact the developer");
             }
             if (message.equals("user_not_found")) {
-                return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, "", -1, null);
+                return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, null);
             }
             //live -> status 2
             //live paused -> 3
             //not live -> status 4
             var element = jsonObject.get("data");
             if (element.isJsonNull()) {
-                return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, "", -1, null);
+                return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, null);
             }
             var data = element.getAsJsonObject();
             var user = data.getAsJsonObject("user");
@@ -58,8 +59,16 @@ public class LiveUserDataMapper
             var roomId = user.get("roomId").getAsString();
             var status = user.get("status").getAsInt();
 
+            TikTokRoomInfo roomInfo = new TikTokRoomInfo();
+            roomInfo.setRoomId(roomId);
+
             var liveRoom = data.getAsJsonObject("liveRoom");
-            long startTime = liveRoom.get("startTime").getAsLong();
+
+            roomInfo.setTitle(liveRoom.get("title").getAsString());
+            roomInfo.setStartTime(liveRoom.get("startTime").getAsLong());
+            roomInfo.setViewersCount(liveRoom.getAsJsonObject("liveRoomStats").get("userCount").getAsInt());
+            roomInfo.setTotalViewersCount(liveRoom.getAsJsonObject("liveRoomStats").get("enterCount").getAsInt());
+            roomInfo.setAgeRestricted(jsonObject.get("statusCode").getAsInt() == TikTokLiveHttpClient.TIKTOK_AGE_RESTRICTED_CODE);
 
             var statusEnum = switch (status) {
                 case 2 -> LiveUserData.UserStatus.Live;
@@ -78,10 +87,55 @@ public class LiveUserDataMapper
                 stats.get("followerCount").getAsLong(),
                 List.of());
 
-            return new LiveUserData.Response(json, statusEnum, roomId, startTime, foundUser);
-        } catch (JsonSyntaxException | IllegalStateException e) {
+            roomInfo.setHost(foundUser);
+            roomInfo.setHostName(foundUser.getName());
+
+            return new LiveUserData.Response(json, statusEnum, roomInfo);
+        } catch (JsonSyntaxException | IllegalStateException | NullPointerException e) {
             logger.warning("Malformed Json: '"+json+"' - Error Message: "+e.getMessage());
-            return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, "", -1, null);
+            return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, null);
+        }
+    }
+
+    public static LiveUserData.Response mapEulerstream(JsonObject jsonObject, Logger logger) {
+        try {
+			JsonObject roomInfoJson = jsonObject.getAsJsonObject("roomInfo");
+			JsonObject userJson = jsonObject.getAsJsonObject("user");
+
+            var roomId = roomInfoJson.get("id").getAsString();
+            var status = roomInfoJson.get("status").getAsInt();
+
+            TikTokRoomInfo roomInfo = new TikTokRoomInfo();
+            roomInfo.setRoomId(roomId);
+            roomInfo.setTitle(roomInfoJson.get("title").getAsString());
+            roomInfo.setStartTime(roomInfoJson.get("startTime").getAsLong());
+            roomInfo.setViewersCount(Optional.ofNullable(roomInfoJson.get("currentViewers")).filter(JsonElement::isJsonPrimitive).map(JsonElement::getAsInt).orElse(0));
+            roomInfo.setTotalViewersCount(roomInfoJson.get("totalViewers").getAsInt());
+
+            var statusEnum = switch (status) {
+                case 2 -> LiveUserData.UserStatus.Live;
+                case 3 -> LiveUserData.UserStatus.LivePaused;
+                case 4 -> LiveUserData.UserStatus.Offline;
+                default -> LiveUserData.UserStatus.NotFound;
+            };
+
+            User foundUser = new User(
+                Long.parseLong(userJson.get("numericUid").getAsString()),
+                userJson.get("uniqueId").getAsString(),
+                userJson.get("nickname").getAsString(),
+                userJson.get("signature").getAsString(),
+                new Picture(userJson.get("avatarUrl").getAsString()),
+                userJson.get("following").getAsLong(),
+                userJson.get("followers").getAsLong(),
+                List.of());
+
+            roomInfo.setHost(foundUser);
+            roomInfo.setHostName(foundUser.getName());
+
+            return new LiveUserData.Response(jsonObject.toString(), statusEnum, roomInfo);
+        } catch (JsonSyntaxException | IllegalStateException | NullPointerException e) {
+            logger.warning("Malformed Json: '"+jsonObject.toString()+"' - Error Message: "+e.getMessage());
+            return new LiveUserData.Response(jsonObject.toString(), LiveUserData.UserStatus.NotFound, null);
         }
     }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/MessagesMapperFactory.java

@@ -104,7 +104,7 @@ public class MessagesMapperFactory {
             var message = mapperHelper.bytesToWebcastObject(inputBytes, WebcastLinkMicArmies.class);
             return MappingResult.of(message, new TikTokLinkMicArmiesEvent(message));
         });
-        mapper.forMessage(WebcastLinkMessage.class, ((inputBytes, messageName, mapperHelper) -> {
+        mapper.forMessage(WebcastLinkMessage.class, (inputBytes, messageName, mapperHelper) -> {
             var message = mapperHelper.bytesToWebcastObject(inputBytes, WebcastLinkMessage.class);
             return MappingResult.of(message, switch (message.getMessageType()) {
                 case TYPE_LINKER_INVITE -> new TikTokLinkInviteEvent(message);
@@ -116,8 +116,7 @@ public class MessagesMapperFactory {
                 case TYPE_LINKER_KICK_OUT -> new TikTokLinkKickOutEvent(message);
                 case TYPE_LINKER_LINKED_LIST_CHANGE -> new TikTokLinkLinkedListChangeEvent(message);
                 case TYPE_LINKER_UPDATE_USER -> new TikTokLinkUpdateUserEvent(message);
-                case TYPE_LINKER_WAITING_LIST_CHANGE, TYPE_LINKER_WAITING_LIST_CHANGE_V2 ->
-                        new TikTokLinkWaitListChangeEvent(message);
+                case TYPE_LINKER_WAITING_LIST_CHANGE, TYPE_LINKER_WAITING_LIST_CHANGE_V2 -> new TikTokLinkWaitListChangeEvent(message);
                 case TYPE_LINKER_MUTE -> new TikTokLinkMuteEvent(message);
                 case TYPE_LINKER_MATCH -> new TikTokLinkRandomMatchEvent(message);
                 case TYPE_LINKER_UPDATE_USER_SETTING -> new TikTokLinkUpdateUserSettingEvent(message);
@@ -130,7 +129,11 @@ public class MessagesMapperFactory {
                 case TYPE_LINKMIC_USER_TOAST -> new TikTokLinkUserToastEvent(message);
                 default -> new TikTokLinkEvent(message);
             });
-        }));
+        });
+        mapper.forMessage(WebcastLinkMicBattleItemCard.class, (inputBytes, messageName, mapperHelper) -> {
+            var message = mapperHelper.bytesToWebcastObject(inputBytes, WebcastLinkMicBattleItemCard.class);
+            return MappingResult.of(message, new TikTokLinkMicBattleItemCard(message));
+        });
         // mapper.webcastObjectToConstructor(WebcastLinkMicMethod.class, TikTokLinkMicMethodEvent.class);
         //  mapper.webcastObjectToConstructor(WebcastLinkMicFanTicketMethod.class, TikTokLinkMicFanTicketEvent.class);
 
@@ -149,4 +152,4 @@ public class MessagesMapperFactory {
         //  mapper.bytesToEvents(WebcastEnvelopeMessage.class, commonHandler::handleEnvelop);
         return mapper;
     }
-}
+}

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

@@ -28,6 +28,7 @@ import io.github.jwdeveloper.tiktok.data.settings.*;
 import io.github.jwdeveloper.tiktok.exceptions.*;
 import io.github.jwdeveloper.tiktok.live.*;
 import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.framing.CloseFrame;
 
 import javax.net.ssl.*;
 import java.net.Proxy;
@@ -56,18 +57,18 @@ public class TikTokWebSocketClient implements LiveSocketClient {
     @Override
     public void start(LiveConnectionData.Response connectionData, LiveClient liveClient) {
         if (isConnected())
-			stop();
+			stop(LiveClientStopType.NORMAL);
 
         messageHandler.handle(liveClient, connectionData.getWebcastResponse());
 
         var headers = new HashMap<>(clientSettings.getHttpSettings().getHeaders());
         headers.put("Cookie", connectionData.getWebsocketCookies());
         webSocketClient = new TikTokWebSocketListener(connectionData.getWebsocketUrl(),
-                headers,
-                clientSettings.getHttpSettings().getTimeout().toMillisPart(),
-                messageHandler,
-                tikTokEventHandler,
-                liveClient);
+            headers,
+            clientSettings.getHttpSettings().getTimeout().toMillisPart(),
+            messageHandler,
+            tikTokEventHandler,
+            liveClient);
 
         ProxyClientSettings proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
         if (proxyClientSettings.isEnabled() && proxyClientSettings.isAllowWebsocket())
@@ -76,7 +77,7 @@ public class TikTokWebSocketClient implements LiveSocketClient {
             connectDefault();
     }
 
-    private void connectDefault() {
+    public void connectDefault() {
         try {
             webSocketClient.connect();
             heartbeatTask.run(webSocketClient, clientSettings.getPingInterval());
@@ -128,9 +129,19 @@ public class TikTokWebSocketClient implements LiveSocketClient {
         }
     }
 
-    public void stop() {
+    public void stop(LiveClientStopType type) {
         if (isConnected()) {
-            webSocketClient.close();
+            switch (type) {
+                case CLOSE_BLOCKING -> {
+					try {
+						webSocketClient.closeBlocking();
+					} catch (InterruptedException e) {
+                        throw new TikTokLiveException("Failed to stop the websocket");
+                    }
+				}
+                case DISCONNECT -> webSocketClient.closeConnection(CloseFrame.NORMAL, "");
+                default -> webSocketClient.close();
+            }
             heartbeatTask.stop();
         }
         webSocketClient = null;

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

@@ -39,9 +39,9 @@ import java.util.*;
 
 public class TikTokWebSocketListener extends WebSocketClient {
 
-    private final LiveMessagesHandler messagesHandler;
-    private final LiveEventsHandler eventHandler;
-    private final LiveClient liveClient;
+    protected final LiveMessagesHandler messagesHandler;
+    protected final LiveEventsHandler eventHandler;
+    protected final LiveClient liveClient;
 
     public TikTokWebSocketListener(URI serverUri,
                                    Map<String, String> httpHeaders,
@@ -67,7 +67,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
         }
     }
 
-    private void handleBinary(byte[] buffer) {
+    protected void handleBinary(byte[] buffer) {
         var websocketPushFrameOptional = getWebcastPushFrame(buffer);
         if (websocketPushFrameOptional.isEmpty()) {
             return;
@@ -97,7 +97,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
 
     @Override
     public void onClose(int code, String reason, boolean remote) {
-        eventHandler.publish(liveClient, new TikTokDisconnectedEvent(reason));
+        eventHandler.publish(liveClient, new TikTokDisconnectedEvent(code, reason));
         liveClient.disconnect();
     }
 
@@ -111,12 +111,8 @@ public class TikTokWebSocketListener extends WebSocketClient {
 
     private Optional<WebcastPushFrame> getWebcastPushFrame(byte[] buffer) {
         try {
-            var websocketMessage = WebcastPushFrame.parseFrom(buffer);
-            if (websocketMessage.getPayload().isEmpty()) {
-                return Optional.empty();
-            }
-            return Optional.of(websocketMessage);
-        } catch (Exception e) {
+            return Optional.of(WebcastPushFrame.parseFrom(buffer)).filter(msg -> !msg.getPayload().isEmpty());
+		} catch (Exception e) {
             throw new TikTokProtocolBufferException("Unable to parse WebcastPushFrame", buffer, e);
         }
     }

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

@@ -44,7 +44,7 @@ public class TikTokWebSocketOfflineClient implements LiveSocketClient {
     }
 
     @Override
-    public void stop() {
+    public void stop(LiveClientStopType type) {
 		if (liveClient != null)
 			handler.publish(liveClient, new TikTokDisconnectedEvent("Stopping"));
 	}

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

@@ -22,43 +22,38 @@
  */
 package io.github.jwdeveloper.tiktok.websocket;
 
+import io.github.jwdeveloper.tiktok.common.AsyncHandler;
 import org.java_websocket.WebSocket;
 
-import java.util.Base64;
+import java.util.*;
+import java.util.concurrent.*;
 
 public class WebSocketHeartbeatTask
 {
-    private Thread thread;
-    private boolean isRunning = false;
-    private final int MAX_TIMEOUT = 250;
-    private final int SLEEP_TIME = 500;
-    private final byte[] heartbeatBytes = Base64.getDecoder().decode("MgJwYjoCaGI="); // Used to be '3A026862' aka ':\x02hb', now is '2\x02pb:\x02hb'.
+    private ScheduledFuture<?> task;
+    private Long commTime;
+
+    private final static byte[] heartbeatBytes = Base64.getDecoder().decode("MgJwYjoCaGI="); // Used to be '3A026862' aka ':\x02hb', now is '2\x02pb:\x02hb'.
 
     public void run(WebSocket webSocket, long pingTaskTime) {
-        stop();
-        thread = new Thread(() -> heartbeatTask(webSocket, pingTaskTime), "heartbeat-task");
-        isRunning = true;
-        thread.start();
-    }
+        stop(); // remove existing task if any
 
-    public void stop() {
-        if (thread != null)
-            thread.interrupt();
-        isRunning = false;
-    }
-
-    private void heartbeatTask(WebSocket webSocket, long pingTaskTime) {
-        while (isRunning) {
+        task = AsyncHandler.getHeartBeatScheduler().scheduleAtFixedRate(() -> {
             try {
                 if (webSocket.isOpen()) {
                     webSocket.send(heartbeatBytes);
-                    Thread.sleep(pingTaskTime + (int) (Math.random() * MAX_TIMEOUT));
-                } else
-                    Thread.sleep(SLEEP_TIME);
+                    commTime = System.currentTimeMillis();
+                } else if (commTime != null && System.currentTimeMillis() - commTime >= 60_000) // Stop if disconnected longer than 60s
+					stop();
             } catch (Exception e) {
-                //TODO we should display some kind of error message
-                isRunning = false;
+                e.printStackTrace();
+                stop();
             }
-        }
+        }, 0, pingTaskTime, TimeUnit.MILLISECONDS);
+    }
+
+    public void stop() {
+        if (task != null)
+            task.cancel(true);
     }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/euler/TikTokWebSocketEulerClient.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023-2024 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.websocket.euler;
+
+import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
+import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.live.*;
+import io.github.jwdeveloper.tiktok.websocket.*;
+import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.framing.CloseFrame;
+
+import java.net.URI;
+import java.util.HashMap;
+
+public class TikTokWebSocketEulerClient implements LiveSocketClient {
+
+    private final LiveClientSettings clientSettings;
+    private final LiveMessagesHandler messageHandler;
+    private final LiveEventsHandler tikTokEventHandler;
+    private WebSocketClient webSocketClient;
+
+    public TikTokWebSocketEulerClient(
+        LiveClientSettings clientSettings,
+        LiveMessagesHandler messageHandler,
+        LiveEventsHandler tikTokEventHandler)
+    {
+        this.clientSettings = clientSettings;
+        this.messageHandler = messageHandler;
+        this.tikTokEventHandler = tikTokEventHandler;
+    }
+
+    @Override
+    public void start(LiveConnectionData.Response connectionData, LiveClient liveClient) {
+        if (isConnected())
+			stop(LiveClientStopType.NORMAL);
+
+        String url = "wss://ws.eulerstream.com?uniqueId=%s&apiKey=%s&features.rawMessages=true".formatted(liveClient.getRoomInfo().getHostName(), clientSettings.getApiKey())
+                     + (clientSettings.isUseEulerstreamWebsocket() ? "&features.useEnterpriseApi=true" : "");
+
+        webSocketClient = new TikTokWebSocketEulerListener(
+            URI.create(url),
+            new HashMap<>(clientSettings.getHttpSettings().getHeaders()),
+            clientSettings.getHttpSettings().getTimeout().toMillisPart(),
+            messageHandler,
+            tikTokEventHandler,
+            liveClient);
+
+        connect();
+    }
+
+    public void connect() {
+        try {
+            webSocketClient.connect();
+        } catch (Exception e) {
+            throw new TikTokLiveException("Failed to connect to the websocket", e);
+        }
+    }
+
+    public void stop(LiveClientStopType type) {
+        if (isConnected()) {
+            switch (type) {
+                case CLOSE_BLOCKING -> {
+                    try {
+                        webSocketClient.closeBlocking();
+                    } catch (InterruptedException e) {
+                        throw new TikTokLiveException("Failed to stop the websocket");
+                    }
+                }
+                case DISCONNECT -> webSocketClient.closeConnection(CloseFrame.NORMAL, "");
+                default -> webSocketClient.close();
+            }
+        }
+        webSocketClient = null;
+    }
+
+    public boolean isConnected() {
+        return webSocketClient != null && webSocketClient.isOpen();
+    }
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/euler/TikTokWebSocketEulerListener.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2023-2024 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.websocket.euler;
+
+import com.google.gson.*;
+import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
+import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
+import io.github.jwdeveloper.tiktok.http.mappers.LiveUserDataMapper;
+import io.github.jwdeveloper.tiktok.live.*;
+import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketListener;
+
+import java.net.URI;
+import java.util.Map;
+
+public class TikTokWebSocketEulerListener extends TikTokWebSocketListener
+{
+
+    public TikTokWebSocketEulerListener(URI serverUri,
+                                        Map<String, String> httpHeaders,
+                                        int connectTimeout,
+                                        LiveMessagesHandler messageHandler,
+                                        LiveEventsHandler tikTokEventHandler,
+                                        LiveClient tikTokLiveClient) {
+        super(serverUri, httpHeaders, connectTimeout, messageHandler, tikTokEventHandler, tikTokLiveClient);
+    }
+
+	@Override
+    public void onMessage(String raw) {
+        try {
+            JsonElement element = JsonParser.parseString(raw);
+            if (element instanceof JsonObject o) {
+                if (o.get("messages") instanceof JsonArray msgs) {
+                    for (JsonElement msg : msgs) {
+                        if (msg instanceof JsonObject oMsg) {
+                            switch (oMsg.get("type").getAsString()) { // Should only receive these 2 types ever
+                                case "workerInfo" -> liveClient.getLogger().info(oMsg.toString()); // Always 1st message
+                                case "roomInfo" -> { // Always 2nd message
+									LiveUserData.Response data = LiveUserDataMapper.mapEulerstream(oMsg.getAsJsonObject("data"), liveClient.getLogger());
+                                    liveClient.getRoomInfo().copy(data.getRoomInfo());
+                                    eventHandler.publish(liveClient, new TikTokRoomInfoEvent(liveClient.getRoomInfo()));
+                                }
+                            }
+                        }
+                    }
+                }
+            } else
+                throw new IllegalArgumentException("Invalid JsonObject: "+element);
+        } catch (Exception e) {
+            e.printStackTrace();
+            eventHandler.publish(liveClient, new TikTokErrorEvent(e));
+        }
+        if (isOpen()) {
+            sendPing();
+        }
+    }
+}

README.md

@@ -70,7 +70,7 @@ Maven
          <dependency>
             <groupId>com.github.jwdeveloper.TikTok-Live-Java</groupId>
             <artifactId>Client</artifactId>
-             <version>1.10.0-Release</version>
+             <version>1.11.0-Release</version>
             <scope>compile</scope>
         </dependency>
    </dependencies>

examples/pom.xml

@@ -41,7 +41,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.10.4-Release</version>
+        <version>1.11.9-Release</version>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>

extension-collector/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
         <artifactId>TikTokLiveJava</artifactId>
-        <version>1.10.4-Release</version>
+        <version>1.11.9-Release</version>
     </parent>
 
 

extension-recorder/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.10.4-Release</version>
+        <version>1.11.9-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>extension-recorder</artifactId>

pom.xml

@@ -7,7 +7,7 @@
     <groupId>io.github.jwdeveloper.tiktok</groupId>
     <artifactId>TikTokLiveJava</artifactId>
     <packaging>pom</packaging>
-    <version>1.10.4-Release</version>
+    <version>1.11.9-Release</version>
     <modules>
         <module>API</module>
         <module>Client</module>
@@ -78,7 +78,6 @@
                     </execution>
                 </executions>
             </plugin>
-
         </plugins>
     </build>
 
@@ -110,7 +109,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
-            <version>RELEASE</version>
+            <version>5.9.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>

tools-readme/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.10.4-Release</version>
+        <version>1.11.9-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>