Introduce dependecy injection container

- TikTokLiveClientBuilder this class has been higly modify to support DI container

API/pom.xml

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

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

@@ -38,8 +38,7 @@ public class TikTokBarrageEvent extends TikTokHeaderEvent {
     private final Picture rightIcon;
     private final String eventName;
     private final int duration;
-
-    private BarrageParam barrageParam;
+    private final BarrageParam barrageParam;
 
     public TikTokBarrageEvent(WebcastBarrageMessage msg) {
         super(msg.getCommon());
@@ -49,6 +48,5 @@ public class TikTokBarrageEvent extends TikTokHeaderEvent {
         rightIcon = Picture.map(msg.getRightIcon());
         duration = msg.getDuration();
         barrageParam = BarrageParam.map(msg);
-
     }
-}
+}

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

@@ -38,9 +38,9 @@ public class TikTokCaptionEvent extends TikTokHeaderEvent {
     String text;
 
     public TikTokCaptionEvent(WebcastCaptionMessage msg) {
-         super(msg.getCommon());
+        super(msg.getCommon());
         captionTimeStamp = msg.getTimeStamp();
         iSOLanguage = msg.getCaptionData().getLanguage();
         text = msg.getCaptionData().getText();
     }
-}
+}

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

@@ -40,18 +40,30 @@ import java.util.List;
 public class TikTokCommentEvent extends TikTokHeaderEvent {
     private final User user;
     private final String text;
-    private final String getUserLanguage;
+    private final String userLanguage;
     private final User mentionedUser;
     private final List<Picture> pictures;
     private final boolean visibleToSender;
 
     public TikTokCommentEvent(WebcastChatMessage msg) {
         super(msg.getCommon());
-        user = User.map(msg.getUser(),msg.getUserIdentity());
+        user = User.map(msg.getUser(), msg.getUserIdentity());
         text = msg.getContent();
         visibleToSender = msg.getVisibleToSender();
-        getUserLanguage = msg.getContentLanguage();
+        userLanguage = msg.getContentLanguage();
         mentionedUser = User.map(msg.getAtUser());
         pictures = msg.getEmotesListList().stream().map(e -> Picture.map(e.getEmote().getImage())).toList();
     }
-}
+
+
+    public static TikTokCommentEvent of(String userName, String message) {
+        var builder = WebcastChatMessage.newBuilder();
+        builder.setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setNickname(userName)
+                .build());
+        builder.setContentLanguage("en");
+        builder.setVisibleToSender(true);
+        builder.setContent(message);
+        return new TikTokCommentEvent(builder.build());
+    }
+}

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

@@ -30,14 +30,10 @@ import lombok.Getter;
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokDetectEvent extends TikTokHeaderEvent {
-   String language;
+    private final String language;
 
-
-  public TikTokDetectEvent(WebcastMsgDetectMessage msg) {
-    super(msg.getCommon());
-    language = msg.getFromRegion();
-  }
-
-
-
-}
+    public TikTokDetectEvent(WebcastMsgDetectMessage msg) {
+        super(msg.getCommon());
+        language = msg.getFromRegion();
+    }
+}

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

@@ -30,9 +30,11 @@ import lombok.Getter;
  * Triggered when the connection gets disconnected. In that case you can call connect() again to have a reconnect logic.
  * Note that you should wait a little bit before attempting a reconnect to to avoid being rate-limited.
  */
+@Getter
 @EventMeta(eventType = EventType.Control)
 public class TikTokDisconnectedEvent extends TikTokLiveClientEvent {
-	@Getter private final String reason;
+	private final String reason;
+
 	public TikTokDisconnectedEvent(String reason) {
 		this.reason = reason.isBlank() ? "None" : reason;
 	}

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

@@ -36,9 +36,9 @@ import lombok.Value;
 @Value
 @EventMeta(eventType = EventType.Message)
 public class TikTokEnvelopeEvent extends TikTokHeaderEvent {
-  User user;
-  public TikTokEnvelopeEvent(WebcastEnvelopeMessage msg) {
-    super(msg.getCommon());
-    user = User.map(msg.getEnvelopeInfo());
-  }
-}
+	User user;
+	public TikTokEnvelopeEvent(WebcastEnvelopeMessage msg) {
+		super(msg.getCommon());
+		user = User.map(msg.getEnvelopeInfo());
+	}
+}

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

@@ -34,9 +34,10 @@ import java.util.List;
 @EventMeta(eventType = EventType.Message)
 public class TikTokIMDeleteEvent extends TikTokHeaderEvent {
 
-    List<Long> userIds;
+    private final List<Long> msgIds, userIds;
     public TikTokIMDeleteEvent(WebcastImDeleteMessage msg) {
         super(msg.getCommon());
+        this.msgIds = msg.getDeleteMsgIdsListList();
         this.userIds = msg.getDeleteUserIdsListList();
     }
-}
+}

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

@@ -31,10 +31,10 @@ import lombok.Getter;
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokInRoomBannerEvent extends TikTokHeaderEvent {
-  private final String json;
+	private final String json;
 
-  public TikTokInRoomBannerEvent(WebcastInRoomBannerMessage msg) {
-    super(msg.getHeader());
-    json = msg.getJson();
-  }
-}
+	public TikTokInRoomBannerEvent(WebcastInRoomBannerMessage msg) {
+		super(msg.getHeader());
+		json = msg.getJson();
+	}
+}

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

@@ -33,11 +33,7 @@ import lombok.Getter;
 @EventMeta(eventType = EventType.Message)
 public class TikTokLinkLayerEvent extends TikTokHeaderEvent {
 
-
     public TikTokLinkLayerEvent(WebcastLinkLayerMessage msg) {
         super(msg.getCommon());
-
     }
-
-
-}
+}

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

@@ -27,12 +27,12 @@ import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
 import io.github.jwdeveloper.tiktok.data.models.LinkMicArmy;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
+import io.github.jwdeveloper.tiktok.messages.enums.LinkMicBattleStatus;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicArmies;
 import lombok.Getter;
 
 import java.util.List;
 
-
 /**
  * Triggered every time a battle participant receives points. Contains the current status of the battle and the army that suported the group.
  */
@@ -40,8 +40,10 @@ import java.util.List;
 @EventMeta(eventType = EventType.Message)
 public class TikTokLinkMicArmiesEvent extends TikTokHeaderEvent {
     private final Long battleId;
-
-    private final Integer battleStatus;
+    /**
+     true if battle is finished otherwise false
+     */
+    private final boolean finished;
 
     private final Picture picture;
 
@@ -52,6 +54,6 @@ public class TikTokLinkMicArmiesEvent extends TikTokHeaderEvent {
         battleId = msg.getId();
         armies = msg.getBattleItemsList().stream().map(LinkMicArmy::new).toList();
         picture = Picture.map(msg.getImage());
-        battleStatus = msg.getBattleStatus();
+        finished = msg.getBattleStatus() == LinkMicBattleStatus.ARMY_FINISHED;
     }
-}
+}

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

@@ -22,29 +22,62 @@
  */
 package io.github.jwdeveloper.tiktok.data.events;
 
-import io.github.jwdeveloper.tiktok.annotations.EventMeta;
-import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.annotations.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
-import io.github.jwdeveloper.tiktok.data.models.LinkMicBattleTeam;
+import io.github.jwdeveloper.tiktok.data.models.battles.*;
+import io.github.jwdeveloper.tiktok.messages.enums.LinkMicBattleStatus;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicBattle;
-import lombok.Getter;
+import lombok.*;
 
-import java.util.List;
+import java.util.*;
 
 /**
- * Triggered every time a battle starts.
+ * Triggered every time a battle starts & ends
  */
 @Getter
 @EventMeta(eventType = EventType.Message)
-public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent {
-  private final Long battleId;
-  private final List<LinkMicBattleTeam> team1;
-  private final List<LinkMicBattleTeam> team2;
+public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
+{
+    private final Long battleId;
+    /**
+     true if battle is finished otherwise false
+     */
+    private final boolean finished;
+    @Getter(AccessLevel.NONE)
+    private final boolean oneVsOne;
+    private final List<Team> teams;
 
-  public TikTokLinkMicBattleEvent(WebcastLinkMicBattle msg) {
-    super(msg.getCommon());
-    battleId = msg.getId();
-    team1 = msg.getTeams1List().stream().map(LinkMicBattleTeam::new).toList();
-    team2 = msg.getTeams2List().stream().map(LinkMicBattleTeam::new).toList();
-  }
-}
+    public TikTokLinkMicBattleEvent(WebcastLinkMicBattle msg) {
+        super(msg.getCommon());
+        battleId = msg.getId();
+        finished = msg.getBattleStatus() == LinkMicBattleStatus.BATTLE_FINISHED;
+        teams = new ArrayList<>();
+        if (msg.getHostTeamCount() == 2) { // 1v1 battle
+            teams.add(new Team1v1(msg.getHostTeam(0), msg));
+            teams.add(new Team1v1(msg.getHostTeam(1), msg));
+            oneVsOne = true;
+        } else { // 2v2 battle
+            if (isFinished()) {
+                teams.add(new Team2v2(msg.getHostData2V2List().stream().filter(data -> data.getTeamNumber() == 1).findFirst().orElse(null), msg));
+                teams.add(new Team2v2(msg.getHostData2V2List().stream().filter(data -> data.getTeamNumber() == 2).findFirst().orElse(null), msg));
+            } else {
+                teams.add(new Team2v2(msg.getHostTeam(0), msg.getHostTeam(1), msg));
+                teams.add(new Team2v2(msg.getHostTeam(2), msg.getHostTeam(3), msg));
+            }
+            oneVsOne = false;
+        }
+
+        // Info:
+        // - msg.getDetailsList() & msg.getViewerTeamList() both only have content when battle is finished
+        // - msg.getDetailsCount() & msg.getViewerTeamCount() always is 2 only when battle is finished
+        // - msg.getHostTeamCount() always is 2 for 1v1 or 4 for 2v2
+    }
+
+    public boolean is1v1() {
+        return oneVsOne;
+    }
+
+    public boolean is2v2() {
+        return !oneVsOne;
+    }
+}

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

@@ -32,10 +32,8 @@ import lombok.Getter;
 @EventMeta(eventType = EventType.Message)
 public class TikTokLinkMicMethodEvent extends TikTokHeaderEvent {
 
-  public TikTokLinkMicMethodEvent(WebcastLinkMicMethod msg) {
-    super(msg.getCommon());
+	public TikTokLinkMicMethodEvent(WebcastLinkMicMethod msg) {
+		super(msg.getCommon());
 
-  }
-
-
-}
+	}
+}

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

@@ -32,15 +32,14 @@ import lombok.Getter;
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokRankTextEvent extends TikTokHeaderEvent {
-  private final String eventType;
+	private final String eventType;
 
-  private final String label;
+	private final String label;
 
-  public TikTokRankTextEvent(WebcastRankTextMessage msg) {
-    super(msg.getCommon());
-    var text = Text.map(msg.getSelfGetBadgeMsg());
-    label = text.getPattern();
-    eventType = text.getKey();
-  }
-
-}
+	public TikTokRankTextEvent(WebcastRankTextMessage msg) {
+		super(msg.getCommon());
+		var text = Text.map(msg.getSelfGetBadgeMsg());
+		label = text.getPattern();
+		eventType = text.getKey();
+	}
+}

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

@@ -33,13 +33,11 @@ import lombok.Getter;
 @EventMeta(eventType = EventType.Message)
 public class TikTokRankUpdateEvent extends TikTokHeaderEvent {
 
-  public TikTokRankUpdateEvent(WebcastHourlyRankMessage msg) {
-    super(msg.getCommon());
+	public TikTokRankUpdateEvent(WebcastHourlyRankMessage msg) {
+		super(msg.getCommon());
+	}
 
-  }
-
-  public TikTokRankUpdateEvent(WebcastRankUpdateMessage msg) {
-    super(msg.getCommon());
-  }
-
-}
+	public TikTokRankUpdateEvent(WebcastRankUpdateMessage msg) {
+		super(msg.getCommon());
+	}
+}

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

@@ -32,25 +32,24 @@ import lombok.Getter;
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokShopEvent extends TikTokHeaderEvent {
-  private final String title;
+	private final String title;
 
-  private final String price;
+	private final String price;
 
-  private final Picture picture;
+	private final Picture picture;
 
-  private final String shopUrl;
+	private final String shopUrl;
 
-  private final String shopName;
+	private final String shopName;
 
-  //Not working
-  public TikTokShopEvent(WebcastOecLiveShoppingMessage msg) {
-    super(msg.getCommon());
-    var data = msg.getShopData();
-    title = data.getTitle();
-    price = data.getPriceString();
-    picture = new Picture(data.getImageUrl());
-    shopUrl = data.getShopUrl();
-    shopName = data.getShopName();
-  }
-
-}
+	//Not working
+	public TikTokShopEvent(WebcastOecLiveShoppingMessage msg) {
+		super(msg.getCommon());
+		var data = msg.getShopData();
+		title = data.getTitle();
+		price = data.getPriceString();
+		picture = new Picture(data.getImageUrl());
+		shopUrl = data.getShopUrl();
+		shopName = data.getShopName();
+	}
+}

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

@@ -36,10 +36,10 @@ import lombok.Getter;
  */
 @Getter
 @EventMeta(eventType = EventType.Message)
-public class TikTokSubscribeEvent extends TikTokHeaderEvent
-{
+public class TikTokSubscribeEvent extends TikTokHeaderEvent {
     private final User user;
 
+
     public TikTokSubscribeEvent(WebcastMemberMessage msg) {
         super(msg.getCommon());
         user = User.map(msg.getUser());
@@ -52,4 +52,11 @@ public class TikTokSubscribeEvent extends TikTokHeaderEvent
         user.addAttribute(UserAttribute.Subscriber);
     }
 
+    public static TikTokSubscribeEvent of(String userName) {
+        return new TikTokSubscribeEvent(WebcastMemberMessage.newBuilder()
+                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setNickname(userName)
+                        .build())
+                .build());
+    }
 }

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

@@ -30,12 +30,13 @@ import lombok.*;
 /**
  * Triggered before the connection is established.
  */
+@Getter
 @EventMeta(eventType = EventType.Control)
 public class TikTokPreConnectionEvent extends TikTokLiveClientEvent
 {
-	@Getter private final LiveUserData.Response userData;
-	@Getter private final LiveData.Response roomData;
-	@Getter @Setter boolean cancelConnection = false;
+	private final LiveUserData.Response userData;
+	private final LiveData.Response roomData;
+	@Setter boolean cancelConnection = false;
 
 	public TikTokPreConnectionEvent(LiveUserData.Response userData, LiveData.Response liveData) {
 		this.userData = userData;

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

@@ -23,6 +23,7 @@
 package io.github.jwdeveloper.tiktok.data.events.gift;
 
 import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.*;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
@@ -32,7 +33,7 @@ import lombok.Getter;
 /**
  * Triggered every time gift is sent
  *
- * @see GiftSendType it has 3 states
+ * @see GiftComboStateType it has 3 states
  *
  * <p>Example when user sends gift with combo</p>
  * <p>>Combo: 1  -> comboState = GiftSendType.Begin</p>
@@ -45,10 +46,21 @@ import lombok.Getter;
 @EventMeta(eventType = EventType.Message)
 @Getter
 public class TikTokGiftComboEvent extends TikTokGiftEvent {
-    private final GiftSendType comboState;
+    private final GiftComboStateType comboState;
 
-    public TikTokGiftComboEvent(Gift gift, User host, WebcastGiftMessage msg, GiftSendType comboState) {
+    public TikTokGiftComboEvent(Gift gift, User host, WebcastGiftMessage msg, GiftComboStateType comboState) {
         super(gift, host, msg);
         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);
+    }
 }

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

@@ -25,6 +25,7 @@ package io.github.jwdeveloper.tiktok.data.events.gift;
 
 import io.github.jwdeveloper.tiktok.annotations.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
+import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.*;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
@@ -55,4 +56,20 @@ public class TikTokGiftEvent extends TikTokHeaderEvent {
         }
         combo = msg.getComboCount();
     }
+
+    public TikTokGiftEvent(Gift gift) {
+        this.gift = gift;
+        user = new User(0L, "sender", new Picture(""));
+        toUser = new User(0L, "receiver", new Picture(""));
+        combo = 1;
+    }
+
+
+    public static TikTokGiftEvent of(Gift gift) {
+        return new TikTokGiftEvent(gift);
+    }
+
+    public static TikTokGiftEvent of(String name, int id, int diamonds) {
+        return TikTokGiftEvent.of(new Gift(id, name, diamonds, ""));
+    }
 }

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

@@ -20,34 +20,26 @@
  * 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.tools.db.tables;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import java.io.PrintWriter;
-import java.io.StringWriter;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
-public class ExceptionInfoModel
-{
-    private String message;
-    private String stackTrace;
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkAcceptNoticeEvent extends TikTokLinkEvent {
 
-    public ExceptionInfoModel(Throwable throwable) {
-        this.message = throwable.getMessage();
-        this.stackTrace = getStackTraceAsString(throwable);
+    private final long fromUserId, fromRoomId, toUserId;
+
+    public TikTokLinkAcceptNoticeEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasAcceptNoticeContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Accept Notice Content!");
+
+        var content = msg.getAcceptNoticeContent();
+        this.fromUserId = content.getFromUserId();
+        this.fromRoomId = content.getFromRoomId();
+        this.toUserId = content.getToUserId();
     }
-
-    public static String getStackTraceAsString(Throwable throwable) {
-        StringWriter sw = new StringWriter();
-        PrintWriter pw = new PrintWriter(sw);
-        throwable.printStackTrace(pw);
-        return sw.toString();
-    }
-
-    // Getters for message and stackTrace
-    public String getMessage() {
-        return message;
-    }
-
-    public String getStackTrace() {
-        return stackTrace;
-    }
-}
+}

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

@@ -20,18 +20,17 @@
  * 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.data.models;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import lombok.Value;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
-@Value
-public class EnumValue
-{
-    public int value;
-    public String name;
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkApplyEvent extends TikTokLinkEvent {
 
-    public static EnumValue Map(Enum<?> _enum)
-    {
-        return new EnumValue(_enum.ordinal() ,_enum.name());
+    public TikTokLinkApplyEvent(WebcastLinkMessage msg) {
+        super(msg);
     }
-}
+}

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkCancelEvent extends TikTokLinkEvent {
+
+    private final long fromUserId, toUserId, cancelType, actionId;
+
+    public TikTokLinkCancelEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasCancelContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Cancel Content!");
+
+        var content = msg.getCancelContent();
+        this.fromUserId = content.getFromUserId();
+        this.toUserId = content.getToUserId();
+        this.cancelType = content.getCancelType();
+        this.actionId = content.getActionId();
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkCloseEvent extends TikTokLinkEvent {
+
+    public TikTokLinkCloseEvent(WebcastLinkMessage msg) {
+        super(msg);
+        // if (!msg.hasCloseContent())
+        //     throw new IllegalArgumentException("Expected WebcastLinkMessage with Close Content!");
+        // Proto Empty
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkCohostListChangeEvent extends TikTokLinkEvent {
+
+    public TikTokLinkCohostListChangeEvent(WebcastLinkMessage msg) {
+        super(msg);
+        // if (!msg.hasCohostListChangeContent())
+        //     throw new IllegalArgumentException("Expected WebcastLinkMessage with Cohost List Change Content!");
+        // Proto Empty
+    }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkCreateEvent extends TikTokLinkEvent {
+
+    private final long hostId, roomId, linkType;
+    public TikTokLinkCreateEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasCreateContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Create Content!");
+
+        var content = msg.getCreateContent();
+        this.hostId = content.getOwnerId();
+        this.roomId = content.getOwnerRoomId();
+        this.linkType = content.getLinkType();
+    }
+}

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

@@ -20,25 +20,29 @@
  * 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.tools.db;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import io.github.jwdeveloper.tiktok.tools.db.tables.TikTokErrorModel;
-
-import org.jdbi.v3.sqlobject.config.RegisterBeanMapper;
-import org.jdbi.v3.sqlobject.customizer.BindBean;
-import org.jdbi.v3.sqlobject.statement.SqlQuery;
-import org.jdbi.v3.sqlobject.statement.SqlUpdate;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.users.ListUser;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
 import java.util.List;
 
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkEnterEvent extends TikTokLinkEvent {
 
-@RegisterBeanMapper(TikTokErrorModel.class)
-public interface TikTokErrorModelDAO
-{
-    @SqlUpdate("INSERT INTO TikTokErrorModel (hostName, errorName, errorType, exceptionContent, message, response, createdAt) " +
-            "VALUES (:hostName, :errorName, :errorType, :exceptionContent, :message, :response, :createdAt)")
-    void insertTikTokMessage(@BindBean TikTokErrorModel message);
+    private final List<ListUser> listUsers;
+    private final int anchorMultiLiveEnum;
 
-    @SqlQuery("SELECT * FROM TikTokErrorModel")
-    List<TikTokErrorModel> selectErrors();
-}
+    public TikTokLinkEnterEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasEnterContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Enter Content!");
+
+        var content = msg.getEnterContent();
+        this.listUsers = content.getLinkedUsersListList().stream().map(ListUser::map).toList();
+        this.anchorMultiLiveEnum = content.getAnchorMultiLiveEnum();
+    }
+}

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

@@ -20,24 +20,24 @@
  * 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.data.events;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import io.github.jwdeveloper.tiktok.annotations.EventMeta;
-import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.annotations.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
-import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
 import lombok.Getter;
 
-import java.util.List;
-
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokLinkEvent extends TikTokHeaderEvent {
 
+    private final String extra, transferExtra;
+    private final long expireTimestamp;
 
     public TikTokLinkEvent(WebcastLinkMessage msg) {
         super(msg.getCommon());
-
+        this.extra = msg.getExtra();
+        this.expireTimestamp = msg.getExpireTimestamp();
+        this.transferExtra = msg.getTransferExtra();
     }
-}
+}

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

@@ -20,25 +20,27 @@
  * 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.tools.collector.api;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
-import io.github.jwdeveloper.tiktok.tools.db.TikTokDatabase;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
-import java.util.function.Consumer;
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkInviteEvent extends TikTokLinkEvent {
 
-public interface DataCollectorBuilder extends DataFilters<DataCollectorBuilder> {
-    DataCollectorBuilder setOutputPath(String path);
-    DataCollectorBuilder setSessionTag(String sessionTimestamp);
+    private final long roomId;
+    private final User inviter;
 
-    DataCollectorBuilder setDatabase(TikTokDatabase database);
+    public TikTokLinkInviteEvent(WebcastLinkMessage msg) {
+        super(msg);
+		if (!msg.hasInviteContent())
+			throw new IllegalArgumentException("Expected WebcastLinkMessage with Invite Content!");
 
-    DataCollectorBuilder configureLiveClient(Consumer<LiveClientBuilder> consumer);
-
-    DataCollectorBuilder addUser(String user);
-
-    DataCollector buildAndRun();
-
-    DataCollector build();
-
-}
+        var content = msg.getInviteContent();
+        this.roomId = content.getFromRoomId();
+        this.inviter = User.map(content.getFromUser());
+	}
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkKickOutEvent extends TikTokLinkEvent {
+
+    private final long fromUserId;
+    private final KickOutReason kickOutReason;
+
+    public TikTokLinkKickOutEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasKickOutContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Kick Out Content!");
+
+        var content = msg.getKickOutContent();
+        this.fromUserId = content.getFromUserId();
+        this.kickOutReason = KickOutReason.values()[content.getKickoutReasonValue()];
+    }
+
+    public enum KickOutReason {
+        KICKOUT_REASON_UNKNOWN,
+        KICKOUT_REASON_FIRST_FRAME_TIMEOUT,
+        KICKOUT_REASON_BY_HOST,
+        KICKOUT_REASON_RTC_LOST_CONNECTION,
+        KICKOUT_REASON_BY_PUNISH,
+        KICKOUT_REASON_BY_ADMIN,
+        KICKOUT_REASON_HOST_REMOVE_ALL_GUESTS
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkLeaveEvent extends TikTokLinkEvent {
+
+    private final long userId, sendLeaveUid, leaveReason;
+    private final String linkmicIdStr;
+
+    public TikTokLinkLeaveEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasLeaveContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Leave Content!");
+
+        var content = msg.getLeaveContent();
+        this.userId = content.getUserId();
+        this.linkmicIdStr = content.getLinkmicIdStr();
+        this.sendLeaveUid = content.getSendLeaveUid();
+        this.leaveReason = content.getLeaveReason();
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkLinkedListChangeEvent extends TikTokLinkEvent {
+
+    public TikTokLinkLinkedListChangeEvent(WebcastLinkMessage msg) {
+        super(msg);
+        // if (!msg.hasLinkedListChangeContent())
+        //     throw new IllegalArgumentException("Expected WebcastLinkMessage with Linked List Change Content!");
+        // Proto Empty
+    }
+}

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

@@ -20,22 +20,29 @@
  * 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.tools.collector.api;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
-import lombok.Data;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.users.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
 import java.util.List;
-import java.util.Set;
-import java.util.function.Consumer;
 
-@Data
-public class TikTokDataCollectorModel {
-    private List<String> users;
-    private String outputPath;
-    private String outputName;
-    private Set<String> eventsFilter;
-    private Set<String> messagesFilter;
-    private String sessionTag ="";
-    private Consumer<LiveClientBuilder> onConfigureLiveClient;
-}
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkListChangeEvent extends TikTokLinkEvent {
+
+    private final List<ListUser> linkedUsers, appliedUsers, connectingUsers;
+
+    public TikTokLinkListChangeEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasListChangeContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with List Change Content!");
+
+        var content = msg.getListChangeContent();
+        this.linkedUsers = content.getLinkedUsersList().stream().map(ListUser::map).toList();
+        this.appliedUsers = content.getAppliedUsersList().stream().map(ListUser::map).toList();
+        this.connectingUsers = content.getConnectingUsersList().stream().map(ListUser::map).toList();
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkMediaChangeEvent extends TikTokLinkEvent {
+
+    private final long op, toUserId, anchorId, roomId, changeScene;
+
+    public TikTokLinkMediaChangeEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasMediaChangeContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Media Change Content!");
+
+        var content = msg.getMediaChangeContent();
+        this.op = content.getOp();
+        this.toUserId = content.getToUserId();
+        this.anchorId = content.getAnchorId();
+        this.roomId = content.getRoomId();
+        this.changeScene = content.getChangeScene();
+    }
+}

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

@@ -20,24 +20,20 @@
  * 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.data.events;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import io.github.jwdeveloper.tiktok.annotations.EventMeta;
-import io.github.jwdeveloper.tiktok.annotations.EventType;
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
-import io.github.jwdeveloper.tiktok.data.models.users.User;
-import lombok.Data;
-
-
-@Data
+@Getter
 @EventMeta(eventType = EventType.Message)
-public class CustomEvent extends TikTokHeaderEvent {
-    private final User user;
-    private final String title;
+public class TikTokLinkMicIdxUpdateEvent extends TikTokLinkEvent {
 
-    public CustomEvent(User user, String title) {
-        this.user = user;
-        this.title = title;
+    public TikTokLinkMicIdxUpdateEvent(WebcastLinkMessage msg) {
+        super(msg);
+        // if (!msg.hasMicIdxUpdateContent())
+        //     throw new IllegalArgumentException("Expected WebcastLinkMessage with Mic Idx Update Content!");
+        // Proto Empty
     }
-}
+}

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

@@ -20,18 +20,25 @@
  * 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.tools.collector.client;
+package io.github.jwdeveloper.tiktok.data.events.link;
 
-import io.github.jwdeveloper.tiktok.tools.db.TikTokDatabase;
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
 
-public class TikTokClientFactory {
-    private final MessagesManager messageCollector;
-    private final TikTokDatabase tikTokDatabase;
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkMuteEvent extends TikTokLinkEvent {
 
-    public TikTokClientFactory(MessagesManager messageCollector, TikTokDatabase tikTokDatabase) {
-        this.messageCollector = messageCollector;
-        this.tikTokDatabase = tikTokDatabase;
+    private final long userId, status;
+
+    public TikTokLinkMuteEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasMuteContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Mute Content!");
+
+        var content = msg.getMuteContent();
+        this.userId = content.getUserId();
+        this.status = content.getStatus();
     }
-
-
-}
+}

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkRandomMatchEvent extends TikTokLinkEvent {
+
+    private final User user;
+    private final long roomId, inviteType, innerChannelId;
+    private final String matchId;
+
+    public TikTokLinkRandomMatchEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasRandomMatchContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Random Match Content!");
+
+        var content = msg.getRandomMatchContent();
+        this.user = User.map(content.getUser());
+        this.roomId = content.getRoomId();
+        this.inviteType = content.getInviteType();
+        this.matchId = content.getMatchId();
+        this.innerChannelId = content.getInnerChannelId();
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkReplyEvent extends TikTokLinkEvent {
+
+    private final long roomId;
+    private final User fromUser, toUser;
+
+    public TikTokLinkReplyEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasReplyContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Reply Content!");
+
+        var content = msg.getReplyContent();
+        this.roomId = content.getFromRoomId();
+        this.fromUser = User.map(content.getFromUser());
+        this.toUser = User.map(content.getToUser());
+    }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkSysKickOutEvent extends TikTokLinkEvent {
+
+    private final long userId;
+    private final String linkmicIdStr;
+
+    public TikTokLinkSysKickOutEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasSysKickOutContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Sys Kick Out Content!");
+
+        var content = msg.getSysKickOutContent();
+        this.userId = content.getUserId();
+        this.linkmicIdStr = content.getLinkmicIdStr();
+    }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkUpdateUserEvent extends TikTokLinkEvent {
+
+    private final long fromUserId, toUserId;
+
+    public TikTokLinkUpdateUserEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasUpdateUserContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with Update User Content!");
+
+        var content = msg.getUpdateUserContent();
+        this.fromUserId = content.getFromUserId();
+        this.toUserId = content.getToUserId();
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkUpdateUserSettingEvent extends TikTokLinkEvent {
+
+    public TikTokLinkUpdateUserSettingEvent(WebcastLinkMessage msg) {
+        super(msg);
+        // if (!msg.hasUpdateUserSettingContent())
+        //     throw new IllegalArgumentException("Expected WebcastLinkMessage with Update User Setting Content!");
+        // Proto Empty
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.data.models.Text;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkUserToastEvent extends TikTokLinkEvent {
+
+    private final long userId, roomId;
+    private final Text displayText;
+
+    public TikTokLinkUserToastEvent(WebcastLinkMessage msg) {
+        super(msg);
+        if (!msg.hasUserToastContent())
+            throw new IllegalArgumentException("Expected WebcastLinkMessage with User Toast Content!");
+
+        var content = msg.getUserToastContent();
+        this.userId = content.getUserId();
+        this.roomId = content.getRoomId();
+        this.displayText = Text.map(content.getDisplayText());
+    }
+}

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2023-2023 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.data.events.link;
+
+import io.github.jwdeveloper.tiktok.annotations.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMessage;
+import lombok.Getter;
+
+@Getter
+@EventMeta(eventType = EventType.Message)
+public class TikTokLinkWaitListChangeEvent extends TikTokLinkEvent {
+
+    public TikTokLinkWaitListChangeEvent(WebcastLinkMessage msg) {
+        super(msg);
+        // if (!msg.hasWaitingListChangeContent())
+        //     throw new IllegalArgumentException("Expected WebcastLinkMessage with Waiting List Change Content!");
+        // Proto Empty
+    }
+}

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

@@ -30,7 +30,7 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 
-/*
+/**
 Triggered when LiveRoomInfo got updated such as likes, viewers, ranking ....
  */
 @Getter
@@ -39,4 +39,4 @@ Triggered when LiveRoomInfo got updated such as likes, viewers, ranking ....
 public class TikTokRoomInfoEvent extends TikTokEvent
 {
     LiveRoomInfo roomInfo;
-}
+}

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

@@ -33,15 +33,13 @@ import lombok.Getter;
 @EventMeta(eventType = EventType.Message)
 public class TikTokRoomPinEvent extends TikTokHeaderEvent
 {
+	private final TikTokCommentEvent pinnedMessage;
+	private final long timestamp;
 
-  private TikTokCommentEvent pinnedMessage;
-  private long timestamp;
-
-  public TikTokRoomPinEvent(WebcastRoomPinMessage msg, TikTokCommentEvent commentEvent)
-  {
-    super(msg.getCommon());
-    this.timestamp = msg.getTimestamp();
-    this.pinnedMessage = commentEvent;
-  }
-
-}
+	public TikTokRoomPinEvent(WebcastRoomPinMessage msg, TikTokCommentEvent commentEvent)
+	{
+		super(msg.getCommon());
+		this.timestamp = msg.getTimestamp();
+		this.pinnedMessage = commentEvent;
+	}
+}

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

@@ -36,13 +36,21 @@ import lombok.Value;
 @EventMeta(eventType = EventType.Message)
 public class TikTokFollowEvent extends TikTokHeaderEvent
 {
-   User user;
-   int totalFollowers;
+    User user;
+    int totalFollowers;
 
-  public TikTokFollowEvent(WebcastSocialMessage msg) {
-    super(msg.getCommon());
-    user = User.map(msg.getUser());
-    totalFollowers = msg.getFollowCount();
-  }
+    public TikTokFollowEvent(WebcastSocialMessage msg) {
+        super(msg.getCommon());
+        user = User.map(msg.getUser());
+        totalFollowers = msg.getFollowCount();
+    }
 
-}
+    public static TikTokFollowEvent of(String userName)
+    {
+        return new TikTokFollowEvent(WebcastSocialMessage.newBuilder()
+            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                .setNickname(userName)
+                .build())
+            .build());
+    }
+}

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

@@ -26,6 +26,7 @@ import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLikeMessage;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastMemberMessage;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSocialMessage;
 import lombok.Getter;
@@ -47,4 +48,13 @@ public class TikTokJoinEvent extends TikTokHeaderEvent {
         user = User.map(msg.getUser());
         totalUsers = msg.getMemberCount();
     }
+
+    public static TikTokJoinEvent of(String userName)
+    {
+        return new TikTokJoinEvent(WebcastMemberMessage.newBuilder()
+                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setNickname(userName)
+                        .build())
+                .build());
+    }
 }

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

@@ -57,4 +57,15 @@ public class TikTokLikeEvent extends TikTokHeaderEvent
         likes = msg.getCount();
         totalLikes = msg.getTotal();
     }
+
+    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()
+                        .setNickname(userName)
+                        .build())
+                .build());
+    }
 }

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

@@ -35,19 +35,18 @@ import lombok.Getter;
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokShareEvent extends TikTokHeaderEvent {
-  private final User user;
-  private final int totalShares;
+	private final User user;
+	private final int totalShares;
 
-  public TikTokShareEvent(WebcastSocialMessage msg, Integer amount) {
-    super(msg.getCommon());
-    user = User.map(msg.getUser());
-    this.totalShares = amount;
-  }
+	public TikTokShareEvent(WebcastSocialMessage msg, Integer amount) {
+		super(msg.getCommon());
+		user = User.map(msg.getUser());
+		this.totalShares = amount;
+	}
 
-  public TikTokShareEvent(WebcastSocialMessage msg) {
-    super(msg.getCommon());
-    user = User.map(msg.getUser());
-    totalShares = 1;
-  }
-
-}
+	public TikTokShareEvent(WebcastSocialMessage msg) {
+		super(msg.getCommon());
+		user = User.map(msg.getUser());
+		totalShares = 1;
+	}
+}

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

@@ -46,4 +46,4 @@ public class LinkMicArmy {
         List<User> Users;
         Integer Points;
     }
-}
+}

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

@@ -44,11 +44,11 @@ public class Picture {
     }
 
     public static Picture map(io.github.jwdeveloper.tiktok.messages.data.Image profilePicture) {
-        var index = profilePicture.getUrlListCount() - 1;
+        var index = profilePicture.getUrlCount() - 1;
         if (index < 0) {
             return new Picture("");
         }
-        var url = profilePicture.getUrlList(index);
+        var url = profilePicture.getUrl(index);
         return new Picture(url);
     }
 
@@ -93,7 +93,7 @@ public class Picture {
         }
     }
 
-    public static Picture Empty() {
+    public static Picture empty() {
         return new Picture("");
     }
 

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2023-2023 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.data.models.battles;
+
+public abstract class Team {
+    /**
+     * Provides a check for verifying if this team represents a 1v1 Team.
+     * @return true if this team is of type {@link Team1v1}, false otherwise.
+     */
+    public boolean is1v1Team() {
+        return this instanceof Team1v1;
+    }
+
+    /**
+     * Provides a check for verifying if this team represents a 1v1 Team.
+     * @return true if this team is of type {@link Team1v1}, false otherwise.
+     */
+    public boolean is2v2Team() {
+        return this instanceof Team2v2;
+    }
+
+    /**
+     * Convenience method to get this team as a {@link Team1v1}. If this team is of some
+     * other type, an {@link IllegalStateException} will result. Hence it is best to use this method
+     * after ensuring that this element is of the desired type by calling {@link #is1v1Team()} first.
+     *
+     * @return this team as a {@link Team1v1}.
+     * @throws IllegalStateException if this team is of another type.
+     */
+    public Team1v1 getAs1v1Team() {
+        if (is1v1Team())
+            return (Team1v1) this;
+        throw new IllegalStateException("Not a 1v1Team: " + this);
+    }
+
+    /**
+     * Convenience method to get this team as a {@link Team2v2}. If this team is of some
+     * other type, an {@link IllegalStateException} will result. Hence it is best to use this method
+     * after ensuring that this element is of the desired type by calling {@link #is2v2Team()} first.
+     *
+     * @return this team as a {@link Team2v2}.
+     * @throws IllegalStateException if this team is of another type.
+     */
+    public Team2v2 getAs2v2Team() {
+        if (is2v2Team())
+            return (Team2v2) this;
+        throw new IllegalStateException("Not a 2v2Team: " + this);
+    }
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2023-2023 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.data.models.battles;
+
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicBattle;
+import lombok.Getter;
+
+import java.util.*;
+
+@Getter
+public class Team1v1 extends Team
+{
+    /** Value >= 0 when finished otherwise -1 */
+    private final int totalPoints;
+    private final int winStreak;
+    private final User host;
+    private final List<Viewer> viewers;
+
+    public Team1v1(WebcastLinkMicBattle.LinkMicBattleHost hostTeam, WebcastLinkMicBattle msg) {
+        long hostId = hostTeam.getId();
+        this.winStreak = msg.getTeamDataList().stream().filter(data -> data.getTeamId() == hostId).map(data -> data.getData().getWinStreak()).findFirst().orElse(-1);
+        this.totalPoints = msg.getDetailsList().stream().filter(dets -> dets.getId() == hostId).map(dets -> dets.getSummary().getPoints()).findFirst().orElse(-1);
+        this.host = new User(hostTeam.getHostGroup(0).getHost(0));
+        this.viewers = msg.getViewerTeamList().stream().filter(team -> team.getId() == hostId).findFirst().map(topViewers ->
+            topViewers.getViewerGroup(0).getViewerList().stream().map(Viewer::new).toList()).orElseGet(ArrayList::new);
+    }
+}

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023-2023 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.data.models.battles;
+
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicBattle;
+import lombok.Getter;
+
+import java.util.*;
+
+@Getter
+public class Team2v2 extends Team {
+    /** Value >= 0 when finished otherwise -1 */
+    private final int totalPoints;
+
+    private final List<User> hosts;
+    private final List<Viewer> viewers;
+
+    public Team2v2(WebcastLinkMicBattle.LinkMicBattleHost hostTeam1, WebcastLinkMicBattle.LinkMicBattleHost hostTeam2, WebcastLinkMicBattle msg) {
+        this.totalPoints = -1;
+        this.hosts = List.of(new User(hostTeam1.getHostGroup(0).getHost(0)), new User(hostTeam2.getHostGroup(0).getHost(0)));
+        this.viewers = new ArrayList<>();
+    }
+
+    public Team2v2(WebcastLinkMicBattle.Host2v2Data hd, WebcastLinkMicBattle msg) {
+        this.totalPoints = hd.getTotalPoints();
+        var host = new User(msg.getHostTeamList().stream().filter(data -> data.getId() == hd.getHostdata(0).getHostId()).findFirst().orElseThrow().getHostGroup(0).getHost(0));
+        var cohost = new User(msg.getHostTeamList().stream().filter(data -> data.getId() == hd.getHostdata(1).getHostId()).findFirst().orElseThrow().getHostGroup(0).getHost(0));
+        this.hosts = List.of(host, cohost);
+        this.viewers = msg.getViewerTeamList().stream().filter(team -> team.getId() == host.getId() || team.getId() == cohost.getId()).findFirst().map(topViewers ->
+            topViewers.getViewerGroup(0).getViewerList().stream().map(Viewer::new).toList()).orElseGet(ArrayList::new);
+    }
+}

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

@@ -20,22 +20,20 @@
  * 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.data.models;
-
+package io.github.jwdeveloper.tiktok.data.models.battles;
 
+import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLinkMicBattle;
-import lombok.Value;
+import lombok.Getter;
 
-import java.util.List;
+@Getter
+public class Viewer {
+    private final User user;
+    private final int points;
 
-@Value
-public class LinkMicBattleTeam {
-    Long teamId;
-    List<User> users;
-
-    public LinkMicBattleTeam(WebcastLinkMicBattle.LinkMicBattleTeam team) {
-        this.teamId = team.getId();
-        this.users = team.getUsersList().stream().map(User::new).toList();
+    public Viewer(WebcastLinkMicBattle.LinkMicBattleTopViewers.TopViewerGroup.TopViewer topViewer) {
+        this.user = new User(topViewer.getId(), null, topViewer.getProfileId(), Picture.map(topViewer.getImages(0)));
+        this.points = topViewer.getPoints();
     }
-}
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/gifts/Gift.java

@@ -1,10 +1,30 @@
+/*
+ * Copyright (c) 2023-2023 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.data.models.gifts;
 
 import com.google.gson.JsonObject;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
-import lombok.*;
-
-import java.util.*;
+import lombok.Data;
 
 @Data
 public class Gift {
@@ -16,7 +36,7 @@ public class Gift {
 
     private final int diamondCost;
 
-    private final Picture picture;
+    private Picture picture;
 
     private final JsonObject properties;
 

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/gifts/GiftComboStateType.java

@@ -22,17 +22,15 @@
  */
 package io.github.jwdeveloper.tiktok.data.models.gifts;
 
-public enum GiftSendType
-{
+public enum GiftComboStateType {
     Finished,
     Begin,
     Active;
 
-    public static GiftSendType fromNumber(long number)
-    {
+    public static GiftComboStateType fromNumber(long number) {
         return switch ((int) number) {
-            case 1, 2, 4 -> GiftSendType.Active;
-            default -> GiftSendType.Finished;
+            case 1, 2, 4 -> GiftComboStateType.Active;
+            default -> GiftComboStateType.Finished;
         };
     }
 }

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2023-2023 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.data.models.users;
+
+import lombok.Getter;
+
+@Getter
+public class ListUser
+{
+    private final User user;
+    private final LinkType linkType;
+    private final long linkMicId, linkStatus, modifyTime, linkerId;
+    private final int userPosition, silenceStatus, roleType;
+
+    public ListUser(io.github.jwdeveloper.tiktok.messages.data.ListUser listUser) {
+        this.user = User.map(listUser.getUser());
+        this.linkMicId = listUser.getLinkmicId();
+        this.linkStatus = listUser.getLinkStatus();
+        this.linkType = LinkType.values()[listUser.getLinkTypeValue()];
+        this.userPosition = listUser.getUserPosition();
+        this.silenceStatus = listUser.getSilenceStatus();
+        this.modifyTime = listUser.getModifyTime();
+        this.linkerId = listUser.getLinkerId();
+        this.roleType = listUser.getRoleType();
+    }
+
+    public static ListUser map(io.github.jwdeveloper.tiktok.messages.data.ListUser listUser) {
+        return new ListUser(listUser);
+    }
+
+    public enum LinkType {
+        UNKNOWN,
+        AUDIO,
+        VIDEO
+    }
+}

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.badges.Badge;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastEnvelopeMessage;
+import io.github.jwdeveloper.tiktok.messages.webcast.*;
 import lombok.AccessLevel;
 import lombok.Getter;
 
@@ -136,6 +136,14 @@ public class User {
         this.picture = picture;
     }
 
+    public User(long id, String name, String profileId, Picture picture) {
+        this(id, name, profileId, picture, 0, 0, List.of(Badge.empty()));
+    }
+
+    public User(WebcastLinkMicBattle.LinkMicBattleHost.HostGroup.Host host) {
+        this(host.getId(), host.getName(), host.getProfileId(), Picture.map(host.getImages(0)));
+    }
+
     public User(io.github.jwdeveloper.tiktok.messages.data.User user) {
         this(user.getId(), user.getDisplayId(), Picture.map(user.getAvatarThumb()));
         profileName = user.getNickname();
@@ -159,10 +167,9 @@ public class User {
         }
     }
 
-
     public static User EMPTY = new User(0L,
             "",
-            Picture.Empty(),
+            Picture.empty(),
             0,
             0,
             List.of(Badge.empty()));
@@ -209,4 +216,18 @@ public class User {
                 0,
                 List.of(Badge.empty()));
     }
+
+    @Override
+    public String toString() {
+        return "User{" +
+            "id=" + id +
+            ", name='" + name + "'" +
+            ", profileName='" + profileName + "'" +
+            ", picture=" + picture +
+            ", following=" + following +
+            ", followers=" + followers +
+            ", badges=" + badges +
+            ", attributes=" + attributes +
+			"}";
+    }
 }

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

@@ -23,20 +23,12 @@
 package io.github.jwdeveloper.tiktok.data.requests;
 
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.Getter;
+import lombok.*;
 
 import java.util.List;
 
 public class GiftsData
 {
-    @Getter
-    public final class Request
-    {
-
-    }
-
     @Getter
     @AllArgsConstructor
     public static final class Response
@@ -44,5 +36,4 @@ public class GiftsData
         private String json;
         private List<Gift> gifts;
     }
-
-}
+}

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

@@ -35,6 +35,7 @@ public class LiveData {
     }
 
     @Data
+    @AllArgsConstructor
     public static class Response {
         private String json;
         private LiveStatus liveStatus;
@@ -45,6 +46,11 @@ public class LiveData {
         private boolean ageRestricted;
         private User host;
         private LiveType liveType;
+        public Response() {
+
+        }
+
+
     }
 
     public enum LiveStatus {

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

@@ -34,30 +34,24 @@ import java.util.TreeMap;
 import java.util.function.Consumer;
 
 
+@Getter
 public class HttpClientSettings {
 
-    @Getter
-    final Map<String, Object> params;
+    private final Map<String, Object> params;
 
-    @Getter
-    final Map<String, String> headers;
+    private final Map<String, String> headers;
 
-    @Getter
-    final Map<String, String> cookies;
-
-    @Getter
-    @Setter
-    ProxyClientSettings proxyClientSettings;
-
-    @Getter
-    Consumer<HttpClient.Builder> onClientCreating;
-
-    @Getter
-    Consumer<HttpRequest.Builder> onRequestCreating;
+    private final Map<String, String> cookies;
 
     @Setter
-    @Getter
-    Duration timeout;
+    private ProxyClientSettings proxyClientSettings;
+
+    private Consumer<HttpClient.Builder> onClientCreating;
+
+    private Consumer<HttpRequest.Builder> onRequestCreating;
+
+    @Setter
+    private Duration timeout;
 
     public HttpClientSettings() {
         this.params = new TreeMap<>();
@@ -65,10 +59,8 @@ public class HttpClientSettings {
         this.cookies = new HashMap<>();
         this.timeout = Duration.ofSeconds(2);
         this.proxyClientSettings = new ProxyClientSettings();
-        this.onClientCreating = (x) -> {
-        };
-        this.onRequestCreating = (x) -> {
-        };
+        this.onClientCreating = (x) -> {};
+        this.onRequestCreating = (x) -> {};
     }
 
     /**

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

@@ -33,12 +33,17 @@ import java.util.logging.Level;
 @Data
 public class LiveClientSettings {
 
+    /**
+     *  Sets client to offline mode, prohibits connection to TikTok servers
+     *  @apiNote Useful when testing client with custom events
+     */
+    private boolean offline;
 
     /**
-     * Determines if gifts data is downloaded before TikTokLive starts,
-     * when `false` then client.giftManager() does not contain initial gifts
+     * Fetch and download gifts data before TikTokLive starts
+     * @apiNote If `false`, client.giftManager() does not contain initial gifts
      */
-    private boolean fetchGifts;
+    private boolean fetchGifts = true;
 
     /**
      * ISO-Language for Client
@@ -76,14 +81,22 @@ public class LiveClientSettings {
     private HttpClientSettings httpSettings;
 
     /**
-     *  Optional: Sometimes not every messages from chat are send to TikTokLiveJava to fix this issue you can set sessionId
-     *  documentation how to obtain sessionId https://github.com/isaackogan/TikTok-Live-Connector#send-chat-messages
+     * Interval of time in milliseconds between pings to TikTok
+     * @apiNote Min: 250 (0.25 seconds), Default: 5000 (5 seconds)
      */
+    private long pingInterval = 5000;
+
+    /** Throw an exception on 18+ Age Restriction */
+    private boolean throwOnAgeRestriction;
+
+    /**
+	 * Optional: Sometimes not every messages from chat are send to TikTokLiveJava to fix this issue you can set sessionId
+	 * @see <a href="https://github.com/isaackogan/TikTok-Live-Connector#send-chat-messages">Documentation: How to obtain sessionId</a>
+	 */
     private String sessionId;
 
     /**
      * Optional: By default roomID is fetched before connect to live, but you can set it manually
-     *
      */
     private String roomId;
 
@@ -92,8 +105,7 @@ public class LiveClientSettings {
      */
     private String apiKey;
 
-    public static LiveClientSettings createDefault()
-    {
+    public static LiveClientSettings createDefault() {
         var httpSettings = new HttpClientSettings();
         httpSettings.getParams().putAll(DefaultClientParams());
         httpSettings.getHeaders().putAll(DefaultRequestHeaders());

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

@@ -31,7 +31,7 @@ import java.util.function.Consumer;
 
 @Getter
 @Setter
-public class ProxyClientSettings implements Iterator<ProxyData>
+public class ProxyClientSettings implements Iterator<ProxyData>, Iterable<ProxyData>
 {
     private boolean enabled, autoDiscard = true, fallback = true;
     private Rotation rotation = Rotation.CONSECUTIVE;
@@ -109,6 +109,14 @@ public class ProxyClientSettings implements Iterator<ProxyData>
         return settings;
     }
 
+    /**
+     * With Iterable<?> interface you can use this object inside For loop!
+     */
+    @Override
+    public Iterator<ProxyData> iterator() {
+        return this;
+    }
+
     public enum Rotation
     {
         /** Rotate addresses consecutively, from proxy 0 -> 1 -> 2 -> ...etc. */

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

@@ -30,10 +30,14 @@ import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
 public interface LiveHttpClient
 {
     /**
-     * @return list of gifts that are available in your country
+     * @return {@link GiftsData.Response} list of gifts that are compiled and available on github
      */
     GiftsData.Response fetchGiftsData();
 
+    /**
+     * @return {@link GiftsData.Response} list of gifts that are available in your region / livestream
+     */
+    GiftsData.Response fetchRoomGiftsData(String room_id);
 
     /**
      * Returns information about user that is having a livestream

API/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokEventListener.java

@@ -22,53 +22,52 @@
  */
 package io.github.jwdeveloper.tiktok.listener;
 
+import io.github.jwdeveloper.tiktok.live.LiveClient;
 
 /**
- *
- * @see ListenersManager
- *
+ * ListenersManager
+ * <p>
  * TikTokEventListener is an alternative way of handing TikTok events.
+ * <p>
+ * {@code TikTokLive.newClient("someuser").addListener(listener);}
+ * <p>
+ * After registertion, all listeners are kept in Listener manager - {@link  LiveClient#getListenersManager()}
+ * <p>
+ * Method in TikTokEventListener should meet requirements below to be detected
+ * <p>- @TikTokEventObserver annotation
+ * <p>- 2 parameters of (LiveClient, Class extending TikTokEvent)
+ * <pre>
+ * {@code
+ * 	public static class CustomListener implements TikTokEventListener
+ *  {
+ *  	@TikTokEventObserver
+ *      public void onError(LiveClient liveClient, TikTokErrorEvent event)
+ *      {
+ *      	System.out.println(event.getException().getMessage());
+ *      }
  *
- *  TikTokLive.newClient("someuser").addListener(listener)
+ *      @TikTokEventObserver
+ *      public void onCommentMessage(LiveClient liveClient, TikTokCommentEvent event)
+ *      {
+ *          System.out.println(event.getText());
+ *      }
  *
- *  After registertion all listeners are kept in Listener manager
- *  that could be obtained by client.getListenerManager();
- *
- *  Method in TikTokEventListener should meet 4 requirements to be detected
- *         - must have @TikTokEventHandler annotation
- *         - must have 2 parameters
- *         - first parameter must be LiveClient
- *         - second must be class that extending TikTokEvent
- *
- *  public static class CustomListener implements TikTokEventListener
- *     {
- *         @TikTokEventHandler
- *         public void onError(LiveClient liveClient, TikTokErrorEvent event)
- *         {
- *             System.out.println(event.getException().getMessage());
- *         }
- *
- *         @TikTokEventHandler
- *         public void onCommentMessage(LiveClient liveClient, TikTokCommentEvent event)
- *         {
- *             System.out.println(event.getText());
- *         }
- *
- *         @TikTokEventHandler
- *         public void onGiftMessage(LiveClient liveClient, TikTokGiftMessageEvent event)
- *         {
- *             System.out.println(event.getGift().getDescription());
- *         }
- *
- *         @TikTokEventHandler
- *         public void onAnyEvent(LiveClient liveClient, TikTokEvent event)
- *         {
- *             System.out.println(event.getClass().getSimpleName());
- *         }
- *     }
+ *      @TikTokEventObserver
+ *      public void onGiftMessage(LiveClient liveClient, TikTokGiftMessageEvent event)
+ *      {
+ *          System.out.println(event.getGift().getDescription());
+ *      }
  *
+ *      @TikTokEventObserver
+ *      public void onAnyEvent(LiveClient liveClient, TikTokEvent event)
+ *      {
+ *          System.out.println(event.getClass().getSimpleName());
+ *      }
+ *   }
+ *  }
+ *  </pre>
  */
 public interface TikTokEventListener
 {
 
-}
+}

API/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokEventListenerBase.java

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2023-2023 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.listener;
+
+import io.github.jwdeveloper.tiktok.data.events.*;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.control.TikTokPreConnectionEvent;
+import io.github.jwdeveloper.tiktok.data.events.envelop.TikTokChestEvent;
+import io.github.jwdeveloper.tiktok.data.events.gift.*;
+import io.github.jwdeveloper.tiktok.data.events.http.TikTokHttpResponseEvent;
+import io.github.jwdeveloper.tiktok.data.events.link.*;
+import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.*;
+import io.github.jwdeveloper.tiktok.data.events.social.*;
+import io.github.jwdeveloper.tiktok.data.events.websocket.*;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+
+public abstract class TikTokEventListenerBase implements TikTokEventListener
+{
+	public void onUnhandledSocial(LiveClient client, TikTokUnhandledSocialEvent event) {}
+
+	public void onChest(LiveClient client, TikTokChestEvent event) {}
+
+	public void onLinkMicFanTicket(LiveClient client, TikTokLinkMicFanTicketEvent event) {}
+
+	public void onEnvelope(LiveClient client, TikTokEnvelopeEvent event) {}
+
+	public void onShop(LiveClient client, TikTokShopEvent event) {}
+
+	public void onDetect(LiveClient client, TikTokDetectEvent event) {}
+
+	public void onLinkLayer(LiveClient client, TikTokLinkLayerEvent event) {}
+
+	public void onConnected(LiveClient client, TikTokConnectedEvent event) {}
+
+	public void onPreConnection(LiveClient client, TikTokPreConnectionEvent event) {}
+
+	public void onCaption(LiveClient client, TikTokCaptionEvent event) {}
+
+	public void onQuestion(LiveClient client, TikTokQuestionEvent event) {}
+
+	public void onRoomPin(LiveClient client, TikTokRoomPinEvent event) {}
+
+	public void onRoomInfo(LiveClient client, TikTokRoomInfoEvent event) {}
+
+	public void onLivePaused(LiveClient client, TikTokLivePausedEvent event) {}
+
+	public void onLiveUnpaused(LiveClient client, TikTokLiveUnpausedEvent event) {}
+
+	public void onLike(LiveClient client, TikTokLikeEvent event) {}
+
+	public void onLink(LiveClient client, TikTokLinkEvent event) {}
+	public void onLinkInvite(LiveClient client, TikTokLinkInviteEvent event) {}
+	public void onLinkReply(LiveClient client, TikTokLinkReplyEvent event) {}
+	public void onLinkCreate(LiveClient client, TikTokLinkCreateEvent event) {}
+	public void onLinkClose(LiveClient client, TikTokLinkCloseEvent event) {}
+	public void onLinkEnter(LiveClient client, TikTokLinkEnterEvent event) {}
+	public void onLinkLeave(LiveClient client, TikTokLinkLeaveEvent event) {}
+	public void onLinkCancel(LiveClient client, TikTokLinkCancelEvent event) {}
+	public void onLinkKickOut(LiveClient client, TikTokLinkKickOutEvent event) {}
+	public void onLinkLinkedListChange(LiveClient client, TikTokLinkLinkedListChangeEvent event) {}
+	public void onLinkUpdateUser(LiveClient client, TikTokLinkUpdateUserEvent event) {}
+	public void onLinkWaitListChange(LiveClient client, TikTokLinkWaitListChangeEvent event) {}
+	public void onLinkMute(LiveClient client, TikTokLinkMuteEvent event) {}
+	public void onLinkRandomMatch(LiveClient client, TikTokLinkRandomMatchEvent event) {}
+	public void onLinkUpdateUserSettings(LiveClient client, TikTokLinkUpdateUserSettingEvent event) {}
+	public void onLinkMicIdxUpdate(LiveClient client, TikTokLinkMicIdxUpdateEvent event) {}
+	public void onLinkListChange(LiveClient client, TikTokLinkListChangeEvent event) {}
+	public void onLinkCohostListChange(LiveClient client, TikTokLinkCohostListChangeEvent event) {}
+	public void onLinkMediaChange(LiveClient client, TikTokLinkMediaChangeEvent event) {}
+	public void onLinkAcceptNotice(LiveClient client, TikTokLinkAcceptNoticeEvent event) {}
+	public void onLinkSysKickOut(LiveClient client, TikTokLinkSysKickOutEvent event) {}
+	public void onLinkUserToast(LiveClient client, TikTokLinkUserToastEvent event) {}
+
+	public void onBarrage(LiveClient client, TikTokBarrageEvent event) {}
+
+	public void onGift(LiveClient client, TikTokGiftEvent event) {}
+
+	public void onGiftCombo(LiveClient client, TikTokGiftComboEvent event) {}
+
+	public void onLinkMicArmies(LiveClient client, TikTokLinkMicArmiesEvent event) {}
+
+	public void onEmote(LiveClient client, TikTokEmoteEvent event) {}
+
+	public void onUnauthorizedMember(LiveClient client, TikTokUnauthorizedMemberEvent event) {}
+
+	public void onInRoomBanner(LiveClient client, TikTokInRoomBannerEvent event) {}
+
+	public void onLinkMicMethod(LiveClient client, TikTokLinkMicMethodEvent event) {}
+
+	public void onSubscribe(LiveClient client, TikTokSubscribeEvent event) {}
+
+	public void onPoll(LiveClient client, TikTokPollEvent event) {}
+
+	public void onFollow(LiveClient client, TikTokFollowEvent event) {}
+
+	public void onComment(LiveClient client, TikTokCommentEvent event) {}
+
+	public void onHttpResponse(LiveClient client, TikTokHttpResponseEvent action) {}
+
+	public void onGoalUpdate(LiveClient client, TikTokGoalUpdateEvent event) {}
+
+	public void onRankUpdate(LiveClient client, TikTokRankUpdateEvent event) {}
+
+	public void onIMDelete(LiveClient client, TikTokIMDeleteEvent event) {}
+
+	public void onLiveEnded(LiveClient client, TikTokLiveEndedEvent event) {}
+
+	public void onError(LiveClient client, TikTokErrorEvent event) {}
+
+	public void onJoin(LiveClient client, TikTokJoinEvent event) {}
+
+	public void onRankText(LiveClient client, TikTokRankTextEvent event) {}
+
+	public void onShare(LiveClient client, TikTokShareEvent event) {}
+
+	public void onUnhandledMember(LiveClient client, TikTokUnhandledMemberEvent event) {}
+
+	public void onSubNotify(LiveClient client, TikTokSubNotifyEvent event) {}
+
+	public void onLinkMicBattle(LiveClient client, TikTokLinkMicBattleEvent event) {}
+
+	public void onDisconnected(LiveClient client, TikTokDisconnectedEvent event) {}
+
+	public void onUnhandledControl(LiveClient client, TikTokUnhandledControlEvent event) {}
+
+	public void onEvent(LiveClient client, TikTokEvent event) {}
+
+	public void onWebsocketResponse(LiveClient client, TikTokWebsocketResponseEvent event) {}
+
+	public void onWebsocketMessage(LiveClient client, TikTokWebsocketMessageEvent event) {}
+
+	public void onWebsocketUnhandledMessage(LiveClient client, TikTokWebsocketUnhandledMessageEvent event) {}
+
+	public void onReconnecting(LiveClient client, TikTokReconnectingEvent event) {}
+}

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

@@ -59,7 +59,16 @@ public interface LiveClient {
     /**
      * Use to manually invoke event
      */
-     void publishEvent(TikTokEvent event);
+    void publishEvent(TikTokEvent event);
+
+
+    /**
+     * @param webcastMessageName name of TikTok protocol-buffer message
+     * @param payloadBase64      protocol-buffer message bytes payload
+     */
+    void publishMessage(String webcastMessageName, String payloadBase64);
+
+    void publishMessage(String webcastMessageName, byte[] payload);
 
     /**
      * Get information about gifts

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

@@ -47,7 +47,7 @@ public interface LiveRoomInfo
      String getRoomId();
      String getHostName();
      String getTitle();
-     User getHostUser();
+     User getHost();
      List<RankingUser> getUsersRanking();
      ConnectionState getConnectionState();
 }

API/src/main/java/io/github/jwdeveloper/tiktok/live/builder/EventConsumer.java

@@ -25,6 +25,7 @@ package io.github.jwdeveloper.tiktok.live.builder;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 
+@FunctionalInterface
 public interface EventConsumer<T extends TikTokEvent>
 {
      void onEvent(LiveClient liveClient, T event);

API/src/main/proto/data.proto

@@ -102,7 +102,8 @@ message Text {
 
 // @Image
 message Image {
-  repeated string urlList = 1;
+  repeated string url = 1;
+  string extras = 2;
   bool isAnimated = 9;
 }
 
@@ -1061,9 +1062,9 @@ message CohostListChangeContent {
 
 
 message LinkerListChangeContent {
-  repeated ListUser linkedUsersList = 1;
-  repeated ListUser appliedUsersList = 2;
-  repeated ListUser connectingUsersList = 3;
+  repeated ListUser linkedUsers = 1;
+  repeated ListUser appliedUsers = 2;
+  repeated ListUser connectingUsers = 3;
 }
 
 message LinkerMediaChangeContent {

API/src/main/proto/enums.proto

@@ -35,6 +35,14 @@ enum LinkmicApplierSortSetting {
   LINKMIC_APPLIER_SORT_SETTING_BY_GIFT_SCORE = 1;
 }
 
+enum LinkMicBattleStatus {
+  BATTLE_ARMY_UNKNOWN = 0;
+  ARMY_ONGOING = 1;
+  ARMY_FINISHED = 2;
+  BATTLE_ONGOING = 4;
+  BATTLE_FINISHED = 5;
+}
+
 enum HashtagNamespace {
   GLOBAL = 0;
   GAMING = 1;
@@ -242,21 +250,21 @@ enum CommonContentCase {
 
 
 enum LinkMessageType {
-  TPYE_LINKER_UNKNOWN = 0;
+  TYPE_LINKER_UNKNOWN = 0;
   TYPE_LINKER_CREATE = 1;
   TYPE_LINKER_CLOSE = 2;
   TYPE_LINKER_INVITE = 3;
   TYPE_LINKER_APPLY = 4;
   TYPE_LINKER_REPLY = 5;
-  TPYE_LINKER_ENTER = 6;
-  TPYE_LINKER_LEAVE = 7;
+  TYPE_LINKER_ENTER = 6;
+  TYPE_LINKER_LEAVE = 7;
   TYPE_LINKER_PERMIT = 8;
-  TPYE_LINKER_CANCEL_INVITE = 9;
+  TYPE_LINKER_CANCEL_INVITE = 9;
   TYPE_LINKER_WAITING_LIST_CHANGE = 10;
   TYPE_LINKER_LINKED_LIST_CHANGE = 11;
   TYPE_LINKER_UPDATE_USER = 12;
-  TPYE_LINKER_KICK_OUT = 13;
-  TPYE_LINKER_CANCEL_APPLY = 14;
+  TYPE_LINKER_KICK_OUT = 13;
+  TYPE_LINKER_CANCEL_APPLY = 14;
   TYPE_LINKER_MUTE = 15;
   TYPE_LINKER_MATCH = 16;
   TYPE_LINKER_UPDATE_USER_SETTING = 17;
@@ -267,8 +275,8 @@ enum LinkMessageType {
   TYPE_LINKER_COHOST_LIST_CHANGE = 22;
   TYPE_LINKER_MEDIA_CHANGE = 23;
   TYPE_LINKER_ACCEPT_NOTICE = 24;
-  TPYE_LINKER_SYS_KICK_OUT = 101;
-  TPYE_LINKMIC_USER_TOAST = 102;
+  TYPE_LINKER_SYS_KICK_OUT = 101;
+  TYPE_LINKMIC_USER_TOAST = 102;
 }
 
 enum MessageType {

API/src/main/proto/webcast.proto

@@ -521,7 +521,7 @@ message WebcastLinkMicArmies {
   uint64 id2 = 4;
   uint64 timeStamp1 = 5;
   uint64 timeStamp2 = 6;
-  int32 battleStatus = 7; // SHOULD BE AN ENUM
+  LinkMicBattleStatus battleStatus = 7;
   uint64 data1 = 8;
   uint64 data2 = 9;
   uint32 data3 = 10;
@@ -574,11 +574,26 @@ message WebcastLinkMicBattle {
   Common common = 1;
   uint64 id = 2;
   LinkMicBattleConfig battleConfig = 3;
-  uint32 data2 = 4;
+  LinkMicBattleStatus battleStatus = 4;
   repeated LinkMicBattleDetails details = 5;
-  repeated LinkMicBattleTeam teams1 = 9;
-  repeated LinkMicBattleTeam teams2 = 10;
+  repeated LinkMicBattleTopViewers viewerTeam = 9;
+  repeated LinkMicBattleHost hostTeam = 10;
   repeated LinkMicBattleTeamData teamData = 13;
+  uint64 unknownData16 = 16;
+  repeated Host2v2Data hostData2v2 = 17;
+
+  message Host2v2Data {
+    uint32 teamNumber = 1;
+    repeated HostData hostdata = 2;
+    uint32 unknownData3 = 3;
+    uint32 totalPoints = 4;
+
+    message HostData {
+      uint64 hostId = 1;
+      uint32 points = 2;
+      string hostIdStr = 3;
+    }
+  }
 
   message LinkMicBattleConfig {
     uint64 id1 = 1;
@@ -586,29 +601,69 @@ message WebcastLinkMicBattle {
     uint32 data1 = 3;
     uint64 id2 = 4;
     uint32 data2 = 5;
+    uint32 data3 = 6;
+    uint32 data4 = 8;
+  }
+
+  message LinkMicBattleTeamData {
+    uint64 teamId = 1;
+    LinkMicBattleData data = 2;
   }
 
   message LinkMicBattleData {
     uint64 id = 1;
     uint32 data1 = 2;
-    uint32 data2 = 3;
+    uint32 winStreak = 3;
     uint32 data3 = 5;
     string url = 6;
   }
 
   message LinkMicBattleDetails {
     uint64 id = 1;
-    LinkMicBattleData details = 2;
+    LinkMicBattleDetailsSummary summary = 2;
+
+    message LinkMicBattleDetailsSummary {
+      uint64 id = 1;
+      uint32 unknownData2 = 2;
+      uint32 points = 3;
+    }
   }
 
-  message LinkMicBattleTeam {
+  message LinkMicBattleTopViewers {
     uint64 id = 1;
-    repeated User users = 2;
+    repeated TopViewerGroup viewerGroup = 2;
+
+    message TopViewerGroup {
+      repeated TopViewer viewer = 1;
+      uint32 points = 2;
+      string hostIdOrTeamNum = 3; // 1v1 Battle = HostId | 2v2 Battle = Team # - 1 & 2
+
+      message TopViewer {
+        uint64 id = 1;
+        uint32 points = 2;
+        string profileId = 3;
+        repeated Image images = 4;
+        string stringId = 6;
+      }
+    }
   }
 
-  message LinkMicBattleTeamData {
-    uint64 teamId = 1;
-    LinkMicBattleData data = 2;
+  message LinkMicBattleHost {
+    uint64 id = 1;
+    repeated HostGroup hostGroup = 2;
+
+    message HostGroup {
+      repeated Host host = 1;
+      uint32 points = 2;
+      string hostId = 3;
+
+      message Host {
+        uint64 id = 1;
+        string profileId = 2;
+        repeated Image images = 3;
+        string name = 4;
+      }
+    }
   }
 }
 
@@ -750,7 +805,7 @@ message WebcastLinkMessage {
   LinkerListChangeContent ListChangeContent = 20;
   CohostListChangeContent CohostListChangeContent = 21;
   LinkerMediaChangeContent MediaChangeContent = 22;
-  LinkerAcceptNoticeContent ReplyAcceptNoticeContent = 23;
+  LinkerAcceptNoticeContent AcceptNoticeContent = 23;
   LinkerSysKickOutContent SysKickOutContent = 101;
   LinkmicUserToastContent UserToastContent = 102;
   string extra = 200;
@@ -792,6 +847,4 @@ message RoomVerifyMessage {
   string content = 3;
   int64 noticeType = 4;
   bool closeRoom = 5;
-}
-
-
+}

Client/pom.xml

@@ -5,12 +5,18 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.3.0-Release</version>
+        <version>1.7.2-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>Client</artifactId>
 
+    <repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+    </repositories>
 
     <dependencies>
         <dependency>
@@ -24,7 +30,12 @@
             <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
-
+        <dependency>
+            <groupId>com.github.jwdeveloper.DepenDance</groupId>
+            <artifactId>DepenDance-Full</artifactId>
+            <version>0.0.18-Release</version>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java</artifactId>

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

@@ -28,7 +28,6 @@ import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
 import io.github.jwdeveloper.tiktok.live.GiftsManager;
 import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 
-import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 public class TikTokLive {
@@ -36,7 +35,7 @@ public class TikTokLive {
     /**
      * Example: https://www.tiktok.com/@dostawcavideo - hostName would be 'dostawcavideo'
      *
-     * @param hostName profile name of Tiktok user could be found in profile link
+     * @param hostName profile name of TikTok user could be found in profile link
      * @return LiveClientBuilder
      */
     public static LiveClientBuilder newClient(String hostName) {
@@ -46,7 +45,7 @@ public class TikTokLive {
     /**
      * Example: https://www.tiktok.com/@dostawcavideo - hostName would be 'dostawcavideo'
      *
-     * @param hostName profile name of Tiktok user could be found in profile link
+     * @param hostName profile name of TikTok user could be found in profile link
      * @return true if live is Online, false if is offline
      */
     public static boolean isLiveOnline(String hostName) {
@@ -56,7 +55,7 @@ public class TikTokLive {
     /**
      * Example: https://www.tiktok.com/@dostawcavideo - hostName would be 'dostawcavideo'
      *
-     * @param hostName profile name of Tiktok user could be found in profile link
+     * @param hostName profile name of TikTok user could be found in profile link
      * @return true if live is Online, false if is offline
      */
     public static CompletableFuture<Boolean> isLiveOnlineAsync(String hostName) {
@@ -66,7 +65,7 @@ public class TikTokLive {
     /**
      * Example: https://www.tiktok.com/@dostawcavideo - hostName would be 'dostawcavideo'
      *
-     * @param hostName profile name of Tiktok user could be found in profile link
+     * @param hostName profile name of TikTok user could be found in profile link
      * @return true is hostName name is valid and exists, false if not
      */
     public static boolean isHostNameValid(String hostName) {
@@ -76,7 +75,7 @@ public class TikTokLive {
     /**
      * Example: https://www.tiktok.com/@dostawcavideo - hostName would be 'dostawcavideo'
      *
-     * @param hostName profile name of Tiktok user could be found in profile link
+     * @param hostName profile name of TikTok user could be found in profile link
      * @return true is hostName name is valid and exists, false if not
      */
     public static CompletableFuture<Boolean> isHostNameValidAsync(String hostName) {
@@ -92,8 +91,6 @@ public class TikTokLive {
         return new TikTokLiveHttpClient();
     }
 
-
-    //I don't like it, but it is reasonable for now
     private static GiftsManager giftsManager;
 
     /**
@@ -102,18 +99,11 @@ public class TikTokLive {
      * @return GiftsManager
      */
     public static GiftsManager gifts() {
-        if (giftsManager != null) {
-            return giftsManager;
-        }
-        synchronized (GiftsManager.class)
-        {
-            if (giftsManager == null)
-            {
-                return new TikTokGiftsManager(requests().fetchGiftsData().getGifts());
+        if (giftsManager == null) {
+            synchronized (GiftsManager.class) {
+                giftsManager = new TikTokGiftsManager(requests().fetchGiftsData().getGifts());
             }
         }
         return giftsManager;
     }
-
-
 }

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

@@ -22,48 +22,51 @@
  */
 package io.github.jwdeveloper.tiktok;
 
-import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokReconnectingEvent;
+import com.google.protobuf.ByteString;
+import io.github.jwdeveloper.dependance.injector.api.annotations.Inject;
+import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.control.*;
 import io.github.jwdeveloper.tiktok.data.events.http.TikTokRoomDataResponseEvent;
 import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
-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.exceptions.*;
-import io.github.jwdeveloper.tiktok.listener.ListenersManager;
-import io.github.jwdeveloper.tiktok.listener.TikTokListenersManager;
-import io.github.jwdeveloper.tiktok.live.GiftsManager;
-import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
-import io.github.jwdeveloper.tiktok.models.ConnectionState;
+import io.github.jwdeveloper.tiktok.data.requests.*;
 import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
+import io.github.jwdeveloper.tiktok.exceptions.*;
+import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
+import io.github.jwdeveloper.tiktok.listener.*;
+import io.github.jwdeveloper.tiktok.live.*;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
+import io.github.jwdeveloper.tiktok.models.ConnectionState;
 import io.github.jwdeveloper.tiktok.websocket.SocketClient;
 
+import java.util.Base64;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
-public class TikTokLiveClient implements LiveClient {
+public class TikTokLiveClient implements LiveClient
+{
     private final TikTokRoomInfo liveRoomInfo;
-    private final TikTokLiveHttpClient httpClient;
+    private final LiveHttpClient httpClient;
     private final SocketClient webSocketClient;
     private final TikTokLiveEventHandler tikTokEventHandler;
     private final LiveClientSettings clientSettings;
-    private final TikTokListenersManager listenersManager;
+    private final ListenersManager listenersManager;
     private final Logger logger;
     private final GiftsManager giftsManager;
+    private final TikTokLiveMessageHandler messageHandler;
 
-    public TikTokLiveClient(GiftsManager giftsManager,
-                            TikTokRoomInfo tikTokLiveMeta,
-                            TikTokLiveHttpClient tiktokHttpClient,
-                            SocketClient webSocketClient,
-                            TikTokLiveEventHandler tikTokEventHandler,
-                            LiveClientSettings clientSettings,
-                            TikTokListenersManager listenersManager,
-                            Logger logger) {
+    public TikTokLiveClient(
+            TikTokLiveMessageHandler messageHandler,
+            GiftsManager giftsManager,
+            TikTokRoomInfo tikTokLiveMeta,
+            LiveHttpClient tiktokHttpClient,
+            SocketClient webSocketClient,
+            TikTokLiveEventHandler tikTokEventHandler,
+            LiveClientSettings clientSettings,
+            ListenersManager listenersManager,
+            Logger logger) {
+        this.messageHandler = messageHandler;
         this.giftsManager = giftsManager;
         this.liveRoomInfo = tikTokLiveMeta;
         this.httpClient = tiktokHttpClient;
@@ -127,6 +130,9 @@ public class TikTokLiveClient implements LiveClient {
         liveRoomInfo.setStartTime(userData.getStartedAtTimeStamp());
         liveRoomInfo.setRoomId(userData.getRoomId());
 
+        if (clientSettings.isFetchGifts())
+            giftsManager.attachGiftsList(httpClient.fetchRoomGiftsData(userData.getRoomId()).getGifts());
+
         if (userData.getUserStatus() == LiveUserData.UserStatus.Offline)
             throw new TikTokLiveOfflineHostException("User is offline: " + liveRoomInfo.getHostName());
 
@@ -136,7 +142,7 @@ public class TikTokLiveClient implements LiveClient {
         var liveDataRequest = new LiveData.Request(userData.getRoomId());
         var liveData = httpClient.fetchLiveData(liveDataRequest);
 
-        if (liveData.isAgeRestricted())
+        if (liveData.isAgeRestricted() && clientSettings.isThrowOnAgeRestriction())
             throw new TikTokLiveException("Livestream for " + liveRoomInfo.getHostName() + " is 18+ or age restricted!");
 
         if (liveData.getLiveStatus() == LiveData.LiveStatus.HostNotFound)
@@ -183,6 +189,20 @@ public class TikTokLiveClient implements LiveClient {
         tikTokEventHandler.publish(this, event);
     }
 
+    @Override
+    public void publishMessage(String webcastMessageName, String payloadBase64) {
+        this.publishMessage(webcastMessageName, Base64.getDecoder().decode(payloadBase64));
+    }
+    @Override
+    public void publishMessage(String webcastMessageName, byte[] payload) {
+
+        var builder = WebcastResponse.Message.newBuilder();
+        builder.setMethod(webcastMessageName);
+        builder.setPayload(ByteString.copyFrom(payload));
+        var message = builder.build();
+        messageHandler.handleSingleMessage(this, message);
+    }
+
     @Override
     public GiftsManager getGiftManager() {
         return giftsManager;

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

@@ -22,6 +22,9 @@
  */
 package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.dependance.Dependance;
+import io.github.jwdeveloper.dependance.api.DependanceContainer;
+import io.github.jwdeveloper.tiktok.mappers.MessagesMapperFactory;
 import io.github.jwdeveloper.tiktok.common.LoggerFactory;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
@@ -29,6 +32,7 @@ import io.github.jwdeveloper.tiktok.data.events.control.TikTokPreConnectionEvent
 import io.github.jwdeveloper.tiktok.data.events.envelop.TikTokChestEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.*;
 import io.github.jwdeveloper.tiktok.data.events.http.TikTokHttpResponseEvent;
+import io.github.jwdeveloper.tiktok.data.events.link.*;
 import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEvent;
 import io.github.jwdeveloper.tiktok.data.events.room.*;
 import io.github.jwdeveloper.tiktok.data.events.social.*;
@@ -37,14 +41,16 @@ import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.gifts.TikTokGiftsManager;
 import io.github.jwdeveloper.tiktok.http.HttpClientFactory;
+import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
 import io.github.jwdeveloper.tiktok.listener.*;
 import io.github.jwdeveloper.tiktok.live.*;
 import io.github.jwdeveloper.tiktok.live.builder.*;
 import io.github.jwdeveloper.tiktok.mappers.*;
-import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
-import io.github.jwdeveloper.tiktok.mappers.handlers.*;
-import io.github.jwdeveloper.tiktok.messages.webcast.*;
-import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokCommonEventHandler;
+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 java.util.*;
 import java.util.concurrent.CompletableFuture;
@@ -54,23 +60,20 @@ import java.util.logging.Logger;
 public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
     protected final LiveClientSettings clientSettings;
-    protected final TikTokLiveEventHandler tikTokEventHandler;
+    protected final TikTokLiveEventHandler eventHandler;
     protected final List<TikTokEventListener> listeners;
-    protected Consumer<TikTokMapper> onCustomMappings;
-    protected Logger logger;
-    protected GiftsManager giftsManager;
+    protected final List<Consumer<TikTokMapper>> onCustomMappings;
 
     public TikTokLiveClientBuilder(String userName) {
         this.clientSettings = LiveClientSettings.createDefault();
         this.clientSettings.setHostName(userName);
-        this.tikTokEventHandler = new TikTokLiveEventHandler();
+        this.eventHandler = new TikTokLiveEventHandler();
         this.listeners = new ArrayList<>();
-        this.onCustomMappings = (e) -> {
-        };
+        this.onCustomMappings = new ArrayList<>();
     }
 
-    public LiveClientBuilder onMapping(Consumer<TikTokMapper> onCustomMappings) {
-        this.onCustomMappings = onCustomMappings;
+    public LiveClientBuilder onMapping(Consumer<TikTokMapper> consumer) {
+        this.onCustomMappings.add(consumer);
         return this;
     }
 
@@ -95,135 +98,80 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         if (clientSettings.getHostName().startsWith("@"))
             clientSettings.setHostName(clientSettings.getHostName().substring(1));
 
+        if (clientSettings.getPingInterval() < 250)
+            throw new TikTokLiveException("Minimum allowed ping interval is 250 millseconds");
+
         var httpSettings = clientSettings.getHttpSettings();
         httpSettings.getParams().put("app_language", clientSettings.getClientLanguage());
         httpSettings.getParams().put("webcast_language", clientSettings.getClientLanguage());
-
-        this.logger = LoggerFactory.create(clientSettings.getHostName(), clientSettings);
-        this.giftsManager = clientSettings.isFetchGifts() ? TikTokLive.gifts() : new TikTokGiftsManager(List.of());
     }
 
+    //TODO each class registered to container should implement own interface,
     public LiveClient build() {
         validate();
 
-        var tiktokRoomInfo = new TikTokRoomInfo();
-        tiktokRoomInfo.setHostName(clientSettings.getHostName());
+        var dependance = Dependance.newContainer();
 
-        var listenerManager = new TikTokListenersManager(listeners, tikTokEventHandler);
+        //config
+        dependance.registerSingleton(LiveClientSettings.class, clientSettings);
+        dependance.registerSingleton(TikTokRoomInfo.class, container ->
+        {
+            var roomInfo = new TikTokRoomInfo();
+            roomInfo.setHostName(clientSettings.getHostName());
+            return roomInfo;
+        });
+        dependance.registerSingleton(Logger.class, LoggerFactory.create(clientSettings.getHostName(), clientSettings));
 
-        var httpClientFactory = new HttpClientFactory(clientSettings);
-        var tikTokLiveHttpClient = new TikTokLiveHttpClient(httpClientFactory, clientSettings);
+        //messages
+        dependance.registerSingleton(TikTokLiveEventHandler.class, eventHandler);
+        dependance.registerSingleton(TikTokLiveMessageHandler.class);
+        dependance.registerSingleton(TikTokLiveMapper.class, (container) ->
+        {
+            var dependace = (DependanceContainer) container.find(DependanceContainer.class);
+            var mapper = MessagesMapperFactory.create(dependace);
+            onCustomMappings.forEach(action -> action.accept(mapper));
+            return mapper;
+        });
 
+        //listeners
+        dependance.registerSingletonList(TikTokEventListener.class, (e) -> listeners);
+        dependance.registerSingleton(ListenersManager.class, TikTokListenersManager.class);
 
-        var eventsMapper = createMapper(giftsManager, tiktokRoomInfo);
-        var messageHandler = new TikTokLiveMessageHandler(tikTokEventHandler, eventsMapper);
+        //networking
+        dependance.registerSingleton(HttpClientFactory.class);
+        if (clientSettings.isOffline()) {
+            dependance.registerSingleton(SocketClient.class, TikTokWebSocketOfflineClient.class);
+            dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpOfflineClient.class);
+        } else {
+            dependance.registerSingleton(SocketClient.class, TikTokWebSocketClient.class);
+            dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpClient.class);
+        }
 
+        //gifts
+        if (clientSettings.isFetchGifts()) {
+            dependance.registerSingleton(GiftsManager.class, TikTokLive.gifts());
+        } else {
+            dependance.registerSingleton(GiftsManager.class, new TikTokGiftsManager(List.of()));
+        }
 
-        var webSocketClient = new TikTokWebSocketClient(
-                clientSettings,
-                messageHandler,
-                tikTokEventHandler);
+        //mapper
+        dependance.registerSingleton(TikTokGenericEventMapper.class);
+        dependance.registerSingleton(TikTokMapperHelper.class, TikTokLiveMapperHelper.class);
+        dependance.registerSingleton(TikTokLiveMapper.class);
 
-        return new TikTokLiveClient(
-                giftsManager,
-                tiktokRoomInfo,
-                tikTokLiveHttpClient,
-                webSocketClient,
-                tikTokEventHandler,
-                clientSettings,
-                listenerManager,
-                logger);
+        //mapper handlers
+        dependance.registerSingleton(TikTokCommonEventHandler.class);
+        dependance.registerSingleton(TikTokGiftEventHandler.class);
+        dependance.registerSingleton(TikTokRoomInfoEventHandler.class);
+        dependance.registerSingleton(TikTokSocialMediaEventHandler.class);
+
+        //client
+        dependance.registerSingleton(LiveClient.class, TikTokLiveClient.class);
+
+        var container = dependance.build();
+        return container.find(LiveClient.class);
     }
 
-    public TikTokLiveMapper createMapper(GiftsManager giftsManager, TikTokRoomInfo roomInfo) {
-
-
-        var eventMapper = new TikTokGenericEventMapper();
-        var mapper = new TikTokLiveMapper(new TikTokLiveMapperHelper(eventMapper));
-
-        //ConnectionEvents events
-        var commonHandler = new TikTokCommonEventHandler();
-        var giftHandler = new TikTokGiftEventHandler(giftsManager, roomInfo);
-        var roomInfoHandler = new TikTokRoomInfoEventHandler(roomInfo);
-        var socialHandler = new TikTokSocialMediaEventHandler(roomInfo);
-
-
-        mapper.forMessage(WebcastControlMessage.class, commonHandler::handleWebcastControlMessage);
-
-        //Room status events
-        mapper.forMessage(WebcastLiveIntroMessage.class, roomInfoHandler::handleIntro);
-        mapper.forMessage(WebcastRoomUserSeqMessage.class, roomInfoHandler::handleUserRanking);
-        mapper.forMessage(WebcastCaptionMessage.class, (inputBytes, messageName, mapperHelper) ->
-        {
-            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastCaptionMessage.class);
-            return MappingResult.of(messageObject, new TikTokCaptionEvent(messageObject));
-        });
-
-
-        //User Interactions events
-        mapper.forMessage(WebcastChatMessage.class, (inputBytes, messageName, mapperHelper) ->
-        {
-            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
-            return MappingResult.of(messageObject, new TikTokCommentEvent(messageObject));
-        });
-        mapper.forMessage(WebcastSubNotifyMessage.class, (inputBytes, messageName, mapperHelper) ->
-        {
-            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastSubNotifyMessage.class);
-            return MappingResult.of(messageObject, new TikTokSubscribeEvent(messageObject));
-        });
-        mapper.forMessage(WebcastEmoteChatMessage.class, (inputBytes, messageName, mapperHelper) ->
-        {
-            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastEmoteChatMessage.class);
-            return MappingResult.of(messageObject, new TikTokEmoteEvent(messageObject));
-        });
-        mapper.forMessage(WebcastQuestionNewMessage.class, (inputBytes, messageName, mapperHelper) ->
-        {
-            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastQuestionNewMessage.class);
-            return MappingResult.of(messageObject, new TikTokQuestionEvent(messageObject));
-        });
-
-        mapper.forMessage(WebcastLikeMessage.class, roomInfoHandler::handleLike);
-        mapper.forMessage(WebcastGiftMessage.class, giftHandler::handleGifts);
-        mapper.forMessage(WebcastSocialMessage.class, socialHandler::handle);
-        mapper.forMessage(WebcastMemberMessage.class, roomInfoHandler::handleMemberMessage);
-
-
-        //Host Interaction events
-        mapper.forMessage(WebcastPollMessage.class, commonHandler::handlePollEvent);
-        mapper.forMessage(WebcastRoomPinMessage.class, commonHandler::handlePinMessage);
-        mapper.forMessage(WebcastChatMessage.class, (inputBytes, messageName, mapperHelper) ->
-        {
-            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
-            return MappingResult.of(messageObject, new TikTokCommentEvent(messageObject));
-        });
-
-
-        //LinkMic events
-        //  mapper.webcastObjectToConstructor(WebcastLinkMicBattle.class, TikTokLinkMicBattleEvent.class);
-        //  mapper.webcastObjectToConstructor(WebcastLinkMicArmies.class, TikTokLinkMicArmiesEvent.class);
-        //  mapper.webcastObjectToConstructor(WebcastLinkMicMethod.class, TikTokLinkMicMethodEvent.class);
-        //  mapper.webcastObjectToConstructor(WebcastLinkMicFanTicketMethod.class, TikTokLinkMicFanTicketEvent.class);
-
-        //Rank events
-        //   mapper.webcastObjectToConstructor(WebcastRankTextMessage.class, TikTokRankTextEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastRankUpdateMessage.class, TikTokRankUpdateEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastHourlyRankMessage.class, TikTokRankUpdateEvent.class);
-
-        //Others events
-        //  mapper.webcastObjectToConstructor(WebcastInRoomBannerMessage.class, TikTokInRoomBannerEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastMsgDetectMessage.class, TikTokDetectEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastBarrageMessage.class, TikTokBarrageEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastUnauthorizedMemberMessage.class, TikTokUnauthorizedMemberEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastOecLiveShoppingMessage.class, TikTokShopEvent.class);
-        //   mapper.webcastObjectToConstructor(WebcastImDeleteMessage.class, TikTokIMDeleteEvent.class);
-        //  mapper.bytesToEvents(WebcastEnvelopeMessage.class, commonHandler::handleEnvelop);
-
-
-        onCustomMappings.accept(mapper);
-        return mapper;
-    }
-
-
     public LiveClient buildAndConnect() {
         var client = build();
         client.connect();
@@ -234,256 +182,366 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return build().connectAsync();
     }
 
+    /**
+     * To do figure out how to use Annotation processor can could dynamically
+     * like Lombok generates methods for all possible events, everytime library
+     * is compiled
+     */
     public TikTokLiveClientBuilder onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
+        eventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
         return this;
     }
 
     public LiveClientBuilder onChest(EventConsumer<TikTokChestEvent> event) {
-        tikTokEventHandler.subscribe(TikTokChestEvent.class, event);
+        eventHandler.subscribe(TikTokChestEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicFanTicket(EventConsumer<TikTokLinkMicFanTicketEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
+        eventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onEnvelope(EventConsumer<TikTokEnvelopeEvent> event) {
-        tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class, event);
+        eventHandler.subscribe(TikTokEnvelopeEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onShop(EventConsumer<TikTokShopEvent> event) {
-        tikTokEventHandler.subscribe(TikTokShopEvent.class, event);
+        eventHandler.subscribe(TikTokShopEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onDetect(EventConsumer<TikTokDetectEvent> event) {
-        tikTokEventHandler.subscribe(TikTokDetectEvent.class, event);
+        eventHandler.subscribe(TikTokDetectEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkLayer(EventConsumer<TikTokLinkLayerEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkLayerEvent.class, event);
+        eventHandler.subscribe(TikTokLinkLayerEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onConnected(EventConsumer<TikTokConnectedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokConnectedEvent.class, event);
+        eventHandler.subscribe(TikTokConnectedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onPreConnection(EventConsumer<TikTokPreConnectionEvent> event) {
-        tikTokEventHandler.subscribe(TikTokPreConnectionEvent.class, event);
+        eventHandler.subscribe(TikTokPreConnectionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onCaption(EventConsumer<TikTokCaptionEvent> event) {
-        tikTokEventHandler.subscribe(TikTokCaptionEvent.class, event);
+        eventHandler.subscribe(TikTokCaptionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onQuestion(EventConsumer<TikTokQuestionEvent> event) {
-        tikTokEventHandler.subscribe(TikTokQuestionEvent.class, event);
+        eventHandler.subscribe(TikTokQuestionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRoomPin(EventConsumer<TikTokRoomPinEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomPinEvent.class, event);
+        eventHandler.subscribe(TikTokRoomPinEvent.class, event);
         return this;
     }
 
     @Override
     public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> event) {
-        tikTokEventHandler.subscribe(eventClass, event);
+        eventHandler.subscribe(eventClass, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomInfoEvent.class, event);
+        eventHandler.subscribe(TikTokRoomInfoEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLivePausedEvent.class, event);
+        eventHandler.subscribe(TikTokLivePausedEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
+        eventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
+        eventHandler.subscribe(TikTokLikeEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLink(EventConsumer<TikTokLinkEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkEvent.class, event);
+        eventHandler.subscribe(TikTokLinkEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkInvite(EventConsumer<TikTokLinkInviteEvent> event) {
+        eventHandler.subscribe(TikTokLinkInviteEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkReply(EventConsumer<TikTokLinkReplyEvent> event) {
+        eventHandler.subscribe(TikTokLinkReplyEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkCreate(EventConsumer<TikTokLinkCreateEvent> event) {
+        eventHandler.subscribe(TikTokLinkCreateEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkClose(EventConsumer<TikTokLinkCloseEvent> event) {
+        eventHandler.subscribe(TikTokLinkCloseEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkEnter(EventConsumer<TikTokLinkEnterEvent> event) {
+        eventHandler.subscribe(TikTokLinkEnterEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkLeave(EventConsumer<TikTokLinkLeaveEvent> event) {
+        eventHandler.subscribe(TikTokLinkLeaveEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkCancel(EventConsumer<TikTokLinkCancelEvent> event) {
+        eventHandler.subscribe(TikTokLinkCancelEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkKickOut(EventConsumer<TikTokLinkKickOutEvent> event) {
+        eventHandler.subscribe(TikTokLinkKickOutEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkLinkedListChange(EventConsumer<TikTokLinkLinkedListChangeEvent> event) {
+        eventHandler.subscribe(TikTokLinkLinkedListChangeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkUpdateUser(EventConsumer<TikTokLinkUpdateUserEvent> event) {
+        eventHandler.subscribe(TikTokLinkUpdateUserEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkWaitListChange(EventConsumer<TikTokLinkWaitListChangeEvent> event) {
+        eventHandler.subscribe(TikTokLinkWaitListChangeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMute(EventConsumer<TikTokLinkMuteEvent> event) {
+        eventHandler.subscribe(TikTokLinkMuteEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkRandomMatch(EventConsumer<TikTokLinkRandomMatchEvent> event) {
+        eventHandler.subscribe(TikTokLinkRandomMatchEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkUpdateUserSettings(EventConsumer<TikTokLinkUpdateUserSettingEvent> event) {
+        eventHandler.subscribe(TikTokLinkUpdateUserSettingEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMicIdxUpdate(EventConsumer<TikTokLinkMicIdxUpdateEvent> event) {
+        eventHandler.subscribe(TikTokLinkMicIdxUpdateEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkListChange(EventConsumer<TikTokLinkListChangeEvent> event) {
+        eventHandler.subscribe(TikTokLinkListChangeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkCohostListChange(EventConsumer<TikTokLinkCohostListChangeEvent> event) {
+        eventHandler.subscribe(TikTokLinkCohostListChangeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMediaChange(EventConsumer<TikTokLinkMediaChangeEvent> event) {
+        eventHandler.subscribe(TikTokLinkMediaChangeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkAcceptNotice(EventConsumer<TikTokLinkAcceptNoticeEvent> event) {
+        eventHandler.subscribe(TikTokLinkAcceptNoticeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkSysKickOut(EventConsumer<TikTokLinkSysKickOutEvent> event) {
+        eventHandler.subscribe(TikTokLinkSysKickOutEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkUserToast(EventConsumer<TikTokLinkUserToastEvent> event) {
+        eventHandler.subscribe(TikTokLinkUserToastEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onBarrage(EventConsumer<TikTokBarrageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokBarrageEvent.class, event);
+        eventHandler.subscribe(TikTokBarrageEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onGift(EventConsumer<TikTokGiftEvent> event) {
-        tikTokEventHandler.subscribe(TikTokGiftEvent.class, event);
+        eventHandler.subscribe(TikTokGiftEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onGiftCombo(EventConsumer<TikTokGiftComboEvent> event) {
-        tikTokEventHandler.subscribe(TikTokGiftComboEvent.class, event);
+        eventHandler.subscribe(TikTokGiftComboEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicArmies(EventConsumer<TikTokLinkMicArmiesEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
+        eventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onEmote(EventConsumer<TikTokEmoteEvent> event) {
-        tikTokEventHandler.subscribe(TikTokEmoteEvent.class, event);
+        eventHandler.subscribe(TikTokEmoteEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnauthorizedMember(EventConsumer<TikTokUnauthorizedMemberEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
+        eventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onInRoomBanner(EventConsumer<TikTokInRoomBannerEvent> event) {
-        tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
+        eventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicMethod(EventConsumer<TikTokLinkMicMethodEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
+        eventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onSubscribe(EventConsumer<TikTokSubscribeEvent> event) {
-        tikTokEventHandler.subscribe(TikTokSubscribeEvent.class, event);
+        eventHandler.subscribe(TikTokSubscribeEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onPoll(EventConsumer<TikTokPollEvent> event) {
-        tikTokEventHandler.subscribe(TikTokPollEvent.class, event);
+        eventHandler.subscribe(TikTokPollEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onFollow(EventConsumer<TikTokFollowEvent> event) {
-        tikTokEventHandler.subscribe(TikTokFollowEvent.class, event);
+        eventHandler.subscribe(TikTokFollowEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
-        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
+        eventHandler.subscribe(TikTokCommentEvent.class, event);
         return this;
     }
 
     @Override
     public LiveClientBuilder onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
-        tikTokEventHandler.subscribe(TikTokHttpResponseEvent.class, action);
+        eventHandler.subscribe(TikTokHttpResponseEvent.class, action);
         return this;
     }
 
     public TikTokLiveClientBuilder onGoalUpdate(EventConsumer<TikTokGoalUpdateEvent> event) {
-        tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
+        eventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRankUpdate(EventConsumer<TikTokRankUpdateEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class, event);
+        eventHandler.subscribe(TikTokRankUpdateEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onIMDelete(EventConsumer<TikTokIMDeleteEvent> event) {
-        tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class, event);
+        eventHandler.subscribe(TikTokIMDeleteEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLiveEndedEvent.class, event);
+        eventHandler.subscribe(TikTokLiveEndedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onError(EventConsumer<TikTokErrorEvent> event) {
-        tikTokEventHandler.subscribe(TikTokErrorEvent.class, event);
+        eventHandler.subscribe(TikTokErrorEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onJoin(EventConsumer<TikTokJoinEvent> event) {
-        tikTokEventHandler.subscribe(TikTokJoinEvent.class, event);
+        eventHandler.subscribe(TikTokJoinEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRankText(EventConsumer<TikTokRankTextEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRankTextEvent.class, event);
+        eventHandler.subscribe(TikTokRankTextEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onShare(EventConsumer<TikTokShareEvent> event) {
-        tikTokEventHandler.subscribe(TikTokShareEvent.class, event);
+        eventHandler.subscribe(TikTokShareEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnhandledMember(EventConsumer<TikTokUnhandledMemberEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
+        eventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onSubNotify(EventConsumer<TikTokSubNotifyEvent> event) {
-        tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class, event);
+        eventHandler.subscribe(TikTokSubNotifyEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicBattle(EventConsumer<TikTokLinkMicBattleEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
+        eventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onDisconnected(EventConsumer<TikTokDisconnectedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class, event);
+        eventHandler.subscribe(TikTokDisconnectedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnhandledControl(EventConsumer<TikTokUnhandledControlEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
+        eventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onEvent(EventConsumer<TikTokEvent> event) {
-        tikTokEventHandler.subscribe(TikTokEvent.class, event);
+        eventHandler.subscribe(TikTokEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event) {
-        tikTokEventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
+        eventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
+        eventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
+        eventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onReconnecting(EventConsumer<TikTokReconnectingEvent> event) {
-        tikTokEventHandler.subscribe(TikTokReconnectingEvent.class, event);
+        eventHandler.subscribe(TikTokReconnectingEvent.class, event);
         return this;
     }
 }

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

@@ -41,19 +41,14 @@ public class TikTokLiveEventHandler {
     public void publish(LiveClient tikTokLiveClient, TikTokEvent tikTokEvent) {
         if (events.containsKey(TikTokEvent.class)) {
             var handlers = events.get(TikTokEvent.class);
-            for (var handle : handlers) {
-                handle.onEvent(tikTokLiveClient, tikTokEvent);
-            }
+            handlers.forEach(handler -> handler.onEvent(tikTokLiveClient,tikTokEvent));
         }
 
-
         if (!events.containsKey(tikTokEvent.getClass())) {
             return;
         }
         var handlers = events.get(tikTokEvent.getClass());
-        for (var handler : handlers) {
-            handler.onEvent(tikTokLiveClient, tikTokEvent);
-        }
+        handlers.forEach(handler -> handler.onEvent(tikTokLiveClient,tikTokEvent));
     }
 
     public <T extends TikTokEvent> void subscribe(Class<?> clazz, EventConsumer<T> event) {
@@ -81,6 +76,5 @@ public class TikTokLiveEventHandler {
 
         var eventSet = events.get(clazz);
         eventSet.remove(consumer);
-
     }
 }

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

@@ -43,6 +43,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
     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_GIFTS_URL = "https://raw.githubusercontent.com/TikTok-LIVE-Private/GiftsGenerator/master/page/public/gifts.json";
+    public static final String TIKTOK_ROOM_GIFTS_URL = TIKTOK_URL_WEBCAST+"gift/list/";
     public static final int TIKTOK_AGE_RESTRICTED_CODE = 4003110;
 
     private final HttpClientFactory httpFactory;
@@ -55,7 +56,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
     public TikTokLiveHttpClient(HttpClientFactory factory, LiveClientSettings settings) {
         this.httpFactory = factory;
         this.clientSettings = settings;
-        this.logger = LoggerFactory.create("HttpClient", clientSettings);
+        this.logger = LoggerFactory.create("HttpClient-"+hashCode(), clientSettings);
         liveUserDataMapper = new LiveUserDataMapper();
         liveDataMapper = new LiveDataMapper();
         giftsDataMapper = new GiftsDataMapper();
@@ -65,6 +66,31 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         this(new HttpClientFactory(LiveClientSettings.createDefault()), LiveClientSettings.createDefault());
     }
 
+    public GiftsData.Response fetchRoomGiftsData(String room_id) {
+        var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
+        if (proxyClientSettings.isEnabled()) {
+            while (proxyClientSettings.hasNext()) {
+                try {
+                    return getRoomGiftsData(room_id);
+                } catch (TikTokProxyRequestException ignored) {}
+            }
+        }
+        return getRoomGiftsData(room_id);
+    }
+
+    public GiftsData.Response getRoomGiftsData(String room_id) {
+        var result = httpFactory.client(TIKTOK_ROOM_GIFTS_URL)
+            .withParam("room_id", room_id)
+            .build()
+            .toJsonResponse();
+
+        if (result.isFailure())
+            throw new TikTokLiveRequestException("Unable to fetch gifts information's - "+result);
+
+        var json = result.getContent();
+        return giftsDataMapper.mapRoom(json);
+    }
+
     public GiftsData.Response fetchGiftsData() {
         var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
         if (proxyClientSettings.isEnabled()) {
@@ -83,7 +109,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
             .toJsonResponse();
 
         if (result.isFailure())
-            throw new TikTokLiveRequestException("Unable to fetch gifts information's"+result.toStack());
+            throw new TikTokLiveRequestException("Unable to fetch gifts information's - "+result);
 
         var json = result.getContent();
         return giftsDataMapper.map(json);
@@ -111,10 +137,10 @@ public class TikTokLiveHttpClient implements LiveHttpClient
             .toJsonResponse();
 
         if (result.isFailure())
-            throw new TikTokLiveRequestException("Unable to get information's about user"+result.toStack());
+            throw new TikTokLiveRequestException("Unable to get information's about user - "+result);
 
         var json = result.getContent();
-        return liveUserDataMapper.map(json);
+        return liveUserDataMapper.map(json, logger);
     }
 
     @Override
@@ -138,7 +164,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
             .toJsonResponse();
 
         if (result.isFailure())
-            throw new TikTokLiveRequestException("Unable to get info about live room"+result.toStack());
+            throw new TikTokLiveRequestException("Unable to get info about live room - "+result);
 
         var json = result.getContent();
         return liveDataMapper.map(json);
@@ -152,8 +178,8 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         try {
             var resultHeader = ActionResult.of(credentialsResponse.headers().firstValue("x-set-tt-cookie"));
             if (resultHeader.isFailure()) {
-                logger.warning("SignServer Headers: "+request.getRoomId()+" - "+credentialsResponse.headers().map());
-                throw new TikTokSignServerException("Sign server did not return the x-set-tt-cookie header"+result.toStack());
+                logger.warning("Sign Server Headers: "+request.getRoomId()+" - "+credentialsResponse.headers().map());
+                throw new TikTokSignServerException("Sign server did not return the x-set-tt-cookie header - "+result);
             }
             var websocketCookie = resultHeader.getContent();
             var webcastResponse = WebcastResponse.parseFrom(credentialsResponse.body());
@@ -169,7 +195,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
 
             return new LiveConnectionData.Response(websocketCookie, webSocketUrl, webcastResponse);
         } catch (InvalidProtocolBufferException e) {
-            throw new TikTokSignServerException("Unable to parse websocket credentials response to WebcastResponse"+result.toStack());
+            throw new TikTokSignServerException("Unable to parse websocket credentials response to WebcastResponse - "+result);
         }
     }
 
@@ -197,7 +223,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         var result = builder.build().toResponse();
 
         if (result.isFailure())
-            throw new TikTokSignServerException("Unable to get websocket connection credentials"+result.toStack());
+            throw new TikTokSignServerException("Unable to get websocket connection credentials - "+result);
 
         return result;
     }

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2023-2023 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;
+
+import io.github.jwdeveloper.tiktok.data.models.Picture;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+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.http.LiveHttpClient;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
+
+import java.net.URI;
+import java.util.List;
+
+public class TikTokLiveHttpOfflineClient implements LiveHttpClient {
+    @Override
+    public GiftsData.Response fetchGiftsData() {
+        return new GiftsData.Response("", List.of());
+    }
+
+    @Override
+    public GiftsData.Response fetchRoomGiftsData(String room_id) {
+        return new GiftsData.Response("", List.of());
+    }
+
+    @Override
+    public LiveUserData.Response fetchLiveUserData(LiveUserData.Request request) {
+        return new LiveUserData.Response("", LiveUserData.UserStatus.Live, "offline_room_id", 0);
+    }
+
+    @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);
+    }
+
+    @Override
+    public LiveConnectionData.Response fetchLiveConnectionData(LiveConnectionData.Request request) {
+        return new LiveConnectionData.Response("",
+                URI.create("https://example.live"),
+                WebcastResponse.newBuilder().build());
+    }
+}

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

@@ -61,11 +61,6 @@ public class TikTokRoomInfo implements LiveRoomInfo {
         return connectionState == state;
     }
 
-    @Override
-    public User getHostUser() {
-        return host;
-    }
-
     public void updateRanking(List<RankingUser> rankingUsers) {
         usersRanking.clear();
         usersRanking.addAll(rankingUsers);

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

@@ -1,16 +1,49 @@
+/*
+ * Copyright (c) 2023-2023 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.common;
 
+import com.google.gson.*;
+import io.github.jwdeveloper.tiktok.http.mappers.*;
 import lombok.Data;
+import lombok.experimental.Accessors;
 
+import java.net.http.*;
 import java.util.Optional;
 import java.util.function.Function;
 
 @Data
 public class ActionResult<T> {
 
+	private static final Gson gson = new Gson().newBuilder().disableHtmlEscaping()
+		.registerTypeHierarchyAdapter(HttpResponse.class, new HttpResponseJsonMapper())
+		.registerTypeHierarchyAdapter(HttpRequest.class, new HttpRequestJsonMapper())
+		.setPrettyPrinting().create();
+
 	private boolean success = true;
-	private T content;
 	private String message;
+	private T content;
+	@Accessors(chain = true, fluent = true)
+	private ActionResult<?> previous;
 
 	protected ActionResult(T object) {
 		this.content = object;
@@ -41,8 +74,9 @@ public class ActionResult<T> {
 	public boolean hasMessage() {
 		return message != null;
 	}
-	public String toStack() {
-		return hasMessage() ? " - "+message : "";
+
+	public boolean hasPrevious() {
+		return previous != null;
 	}
 
 	public boolean hasContent() {
@@ -84,4 +118,18 @@ public class ActionResult<T> {
 	public static <T> ActionResult<T> failure() {
 		return failure(null);
 	}
+
+	public JsonObject toJson() {
+		JsonObject map = new JsonObject();
+		map.addProperty("success", success);
+		map.addProperty("message", message);
+		map.add("content", gson.toJsonTree(content));
+		map.add("previous", hasPrevious() ? previous.toJson() : null);
+		return map;
+	}
+
+	@Override
+	public String toString() {
+		return "ActionResult: "+gson.toJson(toJson());
+	}
 }

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

@@ -1,5 +1,30 @@
+/*
+ * Copyright (c) 2023-2023 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.common;
 
+import lombok.Setter;
+import lombok.experimental.Accessors;
+
 import java.util.Arrays;
 import java.util.stream.Collectors;
 
@@ -7,6 +32,8 @@ public class ActionResultBuilder<T>
 {
 	private final T content;
 	private String message;
+	@Setter @Accessors(fluent = true, chain = true)
+	private ActionResult<?> previous;
 
 	public ActionResultBuilder(T content) {
 		this.content = content;
@@ -18,10 +45,10 @@ public class ActionResultBuilder<T>
 	}
 
 	public ActionResult<T> success() {
-		return ActionResult.success(content, message);
+		return ActionResult.success(content, message).previous(previous);
 	}
 
 	public ActionResult<T> failure() {
-		return ActionResult.success(content, message);
+		return ActionResult.success(content, message).previous(previous);
 	}
 }

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

@@ -1,3 +1,25 @@
+/*
+ * Copyright (c) 2023-2023 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.common;
 
 import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;

Client/src/main/java/io/github/jwdeveloper/tiktok/gifts/TikTokGiftsManager.java

@@ -1,22 +1,41 @@
+/*
+ * Copyright (c) 2023-2023 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.gifts;
 
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.live.GiftsManager;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.function.Predicate;
+import java.util.*;
+import java.util.function.*;
 import java.util.stream.Collectors;
 
+//TODO I should've been called it TikTokGiftsRepository
 public class TikTokGiftsManager implements GiftsManager {
     private final Map<Integer, Gift> giftsByIdIndex;
 
     public TikTokGiftsManager(List<Gift> giftList)
     {
-        giftsByIdIndex = giftList.stream().collect(Collectors.toConcurrentMap(Gift::getId, e -> e));
+        giftsByIdIndex = giftList.stream().collect(Collectors.toConcurrentMap(Gift::getId, Function.identity()));
     }
 
     public void attachGift(Gift gift) {
@@ -32,11 +51,7 @@ public class TikTokGiftsManager implements GiftsManager {
     }
 
     public Gift getById(int giftId) {
-        if (!giftsByIdIndex.containsKey(giftId)) {
-            return Gift.UNDEFINED;
-        }
-
-        return giftsByIdIndex.get(giftId);
+        return giftsByIdIndex.getOrDefault(giftId, Gift.UNDEFINED);
     }
 
     public Gift getByFilter(Predicate<Gift> filter) {
@@ -44,7 +59,7 @@ public class TikTokGiftsManager implements GiftsManager {
                 .stream()
                 .filter(filter)
                 .findFirst()
-                .orElseGet(() -> Gift.UNDEFINED);
+                .orElse(Gift.UNDEFINED);
     }
 
     @Override
@@ -62,4 +77,4 @@ public class TikTokGiftsManager implements GiftsManager {
     public Map<Integer, Gift> toMap() {
         return Collections.unmodifiableMap(giftsByIdIndex);
     }
-}
+}

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

@@ -30,6 +30,7 @@ import lombok.AllArgsConstructor;
 import java.net.*;
 import java.net.http.*;
 import java.nio.charset.*;
+import java.time.*;
 import java.util.*;
 import java.util.regex.*;
 import java.util.stream.Collectors;
@@ -47,7 +48,21 @@ public class HttpClient {
         try {
             var response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
             var result = ActionResult.of(response);
-			return response.statusCode() != 200 ? result.message("HttpResponse Code: ", response.statusCode()).failure() : result.success();
+            return switch (response.statusCode()) {
+                case 420 -> result.message("HttpResponse Code:", response.statusCode(), "| IP Cloudflare Blocked.").failure();
+                case 429 -> {
+                    var wait = response.headers().firstValue("ratelimit-reset");
+					if (wait.isEmpty())
+                        yield result.message("HttpResponse Code:", response.statusCode(), "| Sign server rate limit reached. Try again later.").failure();
+                    Duration duration = Duration.ofSeconds(Long.parseLong(wait.get()));
+                    yield result.message("HttpResponse Code:", response.statusCode(),
+                        String.format("| Sign server rate limit reached. Try again in %02d:%02d.", duration.toMinutesPart(), duration.toSecondsPart())).failure();
+				}
+                case 500, 501, 502, 503 -> result.message("HttpResponse Code:", response.statusCode(), "| Sign server Error. Try again later.").failure();
+                case 504 -> result.message("HttpResponse Code:", response.statusCode(), "| Sign server Timeout. Try again later.").failure();
+                case 200 -> result.success();
+                default -> result.message("HttpResponse Code:", response.statusCode()).failure();
+            };
 		} catch (Exception e) {
             throw new TikTokLiveRequestException(e);
         }

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

@@ -105,6 +105,7 @@ public class HttpProxyClient extends HttpClient {
 					socksConnection.setSSLSocketFactory(sc.getSocketFactory());
 					socksConnection.setConnectTimeout(httpClientSettings.getTimeout().toMillisPart());
 					socksConnection.setReadTimeout(httpClientSettings.getTimeout().toMillisPart());
+					httpClientSettings.getHeaders().forEach(socksConnection::setRequestProperty);
 
 					byte[] body = socksConnection.getInputStream().readAllBytes();
 

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

@@ -22,15 +22,15 @@
  */
 package io.github.jwdeveloper.tiktok.http.mappers;
 
-import com.google.gson.JsonElement;
-import com.google.gson.JsonParser;
+import com.google.gson.*;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
 import io.github.jwdeveloper.tiktok.data.requests.GiftsData;
 
-import java.util.ArrayList;
+import java.util.List;
 
 public class GiftsDataMapper {
+
     public GiftsData.Response map(String json) {
         var parsedJson = JsonParser.parseString(json);
         var jsonObject = parsedJson.getAsJsonObject();
@@ -42,7 +42,6 @@ public class GiftsDataMapper {
         return new GiftsData.Response(json, gifts);
     }
 
-
     private Gift mapSingleGift(JsonElement jsonElement) {
         var jsonObject = jsonElement.getAsJsonObject();
 
@@ -52,4 +51,34 @@ public class GiftsDataMapper {
         var image = jsonObject.get("image").getAsString();
         return new Gift(id, name, diamondCost, new Picture(image), jsonObject);
     }
-}
+
+    public 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) {
+            var gifts = giftArray.asList().parallelStream()
+                .map(this::mapSingleRoomGift)
+                .toList();
+
+            return new GiftsData.Response(json, gifts);
+        }
+        return new GiftsData.Response("", List.of());
+    }
+
+    private Gift mapSingleRoomGift(JsonElement jsonElement) {
+        var jsonObject = jsonElement.getAsJsonObject();
+
+        var id = jsonObject.get("id").getAsInt();
+        var name = jsonObject.get("name").getAsString();
+        var diamondCost = jsonObject.get("diamond_count").getAsInt();
+        Picture picture;
+        if (jsonObject.get("image") instanceof JsonObject image && image.get("url_list") instanceof JsonArray urls && !urls.isEmpty()) {
+            String url = urls.get(0).getAsString();
+            if (url.endsWith(".webp"))
+                url = url.substring(0, url.length()-4)+"png";
+            picture = new Picture(url);
+        } else
+            picture = Picture.empty();
+        return new Gift(id, name, diamondCost, picture, jsonObject);
+    }
+}

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

@@ -20,26 +20,24 @@
  * 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.tools.db.tables;
+package io.github.jwdeveloper.tiktok.http.mappers;
 
-import lombok.Data;
+import com.google.gson.*;
 
-@Data
-public class TikTokErrorModel
+import java.lang.reflect.Type;
+import java.net.http.HttpRequest;
+
+public class HttpRequestJsonMapper implements JsonSerializer<HttpRequest>
 {
-    private Integer id;
-
-    private String hostName;
-
-    private String errorName;
-
-    private String errorType;
-
-    private String exceptionContent;
-
-    private String message;
-
-    private String response;
-
-    private String createdAt;
-}
+	@Override
+	public JsonElement serialize(HttpRequest src, Type typeOfSrc, JsonSerializationContext context) {
+		JsonObject object = new JsonObject();
+		object.addProperty("method", src.method());
+		object.add("timeout", context.serialize(src.timeout().toString()));
+		object.addProperty("expectContinue", src.expectContinue());
+		object.add("uri", context.serialize(src.uri()));
+		object.add("version", context.serialize(src.version().toString()));
+		object.add("headers", context.serialize(src.headers().map()));
+		return object;
+	}
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2023 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.http.mappers;
+
+import com.google.gson.*;
+
+import java.lang.reflect.Type;
+import java.net.http.HttpResponse;
+
+public class HttpResponseJsonMapper implements JsonSerializer<HttpResponse>
+{
+	@Override
+	public JsonElement serialize(HttpResponse src, Type typeOfSrc, JsonSerializationContext context) {
+		JsonObject object = new JsonObject();
+		object.addProperty("statusCode", src.statusCode());
+		object.add("request", context.serialize(src.request()));
+		object.add("headers", context.serialize(src.headers().map()));
+		object.add("body", context.serialize(src.body()));
+		object.add("uri", context.serialize(src.uri().toString()));
+		object.add("version", context.serialize(src.version().toString()));
+		return object;
+	}
+}

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

@@ -65,8 +65,7 @@ public class LiveDataMapper {
                 default -> LiveData.LiveStatus.HostNotFound;
             };
             response.setLiveStatus(statusValue);
-        } else if (data.has("prompts") && jsonObject.has("status_code") &&
-            data.get("prompts").getAsString().isEmpty() && jsonObject.get("status_code").isJsonPrimitive()) {
+        } else if (data.has("prompts") && data.get("prompts").getAsString().isEmpty() && jsonObject.has("status_code")) {
             response.setAgeRestricted(jsonObject.get("status_code").getAsInt() == TikTokLiveHttpClient.TIKTOK_AGE_RESTRICTED_CODE);
         } else {
             response.setLiveStatus(LiveData.LiveStatus.HostNotFound);

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

@@ -22,45 +22,52 @@
  */
 package io.github.jwdeveloper.tiktok.http.mappers;
 
-import com.google.gson.JsonParser;
+import com.google.gson.*;
 import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 
+import java.util.logging.Logger;
+
 public class LiveUserDataMapper
 {
-    public LiveUserData.Response map(String json) {
-        var jsonObject = JsonParser.parseString(json).getAsJsonObject();
+    public LiveUserData.Response map(String json, Logger logger) {
+        try {
+            var jsonObject = JsonParser.parseString(json).getAsJsonObject();
 
-        var message = jsonObject.get("message").getAsString();
+            var message = jsonObject.get("message").getAsString();
 
-        if (message.equals("params_error")) {
-            throw new TikTokLiveRequestException("fetchRoomIdFromTiktokApi -> Unable to fetch roomID, contact the developer");
-        }
-        if (message.equals("user_not_found")) {
+            if (message.equals("params_error")) {
+                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);
+            }
+            //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);
+            }
+            var data = element.getAsJsonObject();
+            var user = data.getAsJsonObject("user");
+            var roomId = user.get("roomId").getAsString();
+            var status = user.get("status").getAsInt();
+
+            var liveRoom = data.getAsJsonObject("liveRoom");
+            long startTime = liveRoom.get("startTime").getAsLong();
+
+            var statusEnum = switch (status) {
+                case 2 -> LiveUserData.UserStatus.Live;
+                case 3 -> LiveUserData.UserStatus.LivePaused;
+                case 4 -> LiveUserData.UserStatus.Offline;
+                default -> LiveUserData.UserStatus.NotFound;
+            };
+
+            return new LiveUserData.Response(json, statusEnum, roomId, startTime);
+        } catch (JsonSyntaxException | IllegalStateException e) {
+            logger.warning("Malformed Json: '"+json+"' - Error Message: "+e.getMessage());
             return new LiveUserData.Response(json, LiveUserData.UserStatus.NotFound, "", -1);
         }
-        //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);
-        }
-        var data = element.getAsJsonObject();
-        var user = data.getAsJsonObject("user");
-        var roomId = user.get("roomId").getAsString();
-        var status = user.get("status").getAsInt();
-
-        var liveRoom = data.getAsJsonObject("liveRoom");
-        long startTime = liveRoom.get("startTime").getAsLong();
-
-        var statusEnum = switch (status) {
-            case 2 -> LiveUserData.UserStatus.Live;
-            case 3 -> LiveUserData.UserStatus.LivePaused;
-            case 4 -> LiveUserData.UserStatus.Offline;
-            default -> LiveUserData.UserStatus.NotFound;
-        };
-
-        return new LiveUserData.Response(json, statusEnum, roomId, startTime);
     }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokListenersManager.java

@@ -96,16 +96,17 @@ public class TikTokListenersManager implements ListenersManager {
                         m.isAnnotationPresent(TikTokEventObserver.class)).toList();
         var eventsMap = new HashMap<Class<?>, List<EventConsumer<?>>>();
         for (var method : methods) {
-            var eventClazz = method.getParameterTypes()[1];
+            var liveclientClass = method.getParameterTypes()[0];
+            var eventClass = method.getParameterTypes()[1];
 
-            if (eventClazz.isAssignableFrom(LiveClient.class) &&
-                    !eventClazz.equals(LiveClient.class)) {
-                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 1nd parameter must instance of " + LiveClient.class.getName());
+            if (!LiveClient.class.isAssignableFrom(liveclientClass) && !liveclientClass.equals(LiveClient.class)) {
+                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 1st parameter must be instance of " + LiveClient.class.getName()
+                    + " | Invalid parameter class: "+liveclientClass.getName());
             }
 
-            if (eventClazz.isAssignableFrom(TikTokEvent.class) &&
-                    !eventClazz.equals(TikTokEvent.class)) {
-                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 2nd parameter must instance of " + TikTokEvent.class.getName());
+            if (!TikTokEvent.class.isAssignableFrom(eventClass) && !eventClass.equals(TikTokEvent.class)) {
+                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 2nd parameter must be instance of " + TikTokEvent.class.getName()
+                    + " | Invalid parameter class: "+eventClass.getName());
             }
 
             EventConsumer eventMethodRef = (liveClient, event) ->
@@ -117,7 +118,7 @@ public class TikTokListenersManager implements ListenersManager {
                     throw new TikTokEventListenerMethodException(e);
                 }
             };
-            eventsMap.computeIfAbsent(eventClazz, (a) -> new ArrayList<>()).add(eventMethodRef);
+            eventsMap.computeIfAbsent(eventClass, (a) -> new ArrayList<>()).add(eventMethodRef);
         }
         return new ListenerBindingModel(listener, eventsMap);
     }

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

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2023-2023 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.mappers;
+
+import io.github.jwdeveloper.dependance.api.DependanceContainer;
+import io.github.jwdeveloper.dependance.injector.api.containers.Container;
+import io.github.jwdeveloper.tiktok.TikTokRoomInfo;
+import io.github.jwdeveloper.tiktok.data.events.*;
+import io.github.jwdeveloper.tiktok.data.events.link.*;
+import io.github.jwdeveloper.tiktok.live.GiftsManager;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokCommonEventHandler;
+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.messages.webcast.*;
+
+import static io.github.jwdeveloper.tiktok.messages.enums.LinkMessageType.*;
+
+public class MessagesMapperFactory {
+    public static TikTokLiveMapper create(DependanceContainer container) {
+
+        var mapper = container.find(TikTokLiveMapper.class);
+
+        //ConnectionEvents events
+        var commonHandler = container.find(TikTokCommonEventHandler.class);
+        var giftHandler = container.find(TikTokGiftEventHandler.class);
+        var roomInfoHandler = container.find(TikTokRoomInfoEventHandler.class);
+        var socialHandler = container.find(TikTokSocialMediaEventHandler.class);
+
+
+        mapper.forMessage(WebcastControlMessage.class, commonHandler::handleWebcastControlMessage);
+
+        //Room status events
+        mapper.forMessage(WebcastLiveIntroMessage.class, roomInfoHandler::handleIntro);
+        mapper.forMessage(WebcastRoomUserSeqMessage.class, roomInfoHandler::handleUserRanking);
+        mapper.forMessage(WebcastCaptionMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastCaptionMessage.class);
+            return MappingResult.of(messageObject, new TikTokCaptionEvent(messageObject));
+        });
+
+
+        //User Interactions events
+        mapper.forMessage(WebcastChatMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
+            return MappingResult.of(messageObject, new TikTokCommentEvent(messageObject));
+        });
+        mapper.forMessage(WebcastSubNotifyMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastSubNotifyMessage.class);
+            return MappingResult.of(messageObject, new TikTokSubscribeEvent(messageObject));
+        });
+        mapper.forMessage(WebcastEmoteChatMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastEmoteChatMessage.class);
+            return MappingResult.of(messageObject, new TikTokEmoteEvent(messageObject));
+        });
+        mapper.forMessage(WebcastQuestionNewMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastQuestionNewMessage.class);
+            return MappingResult.of(messageObject, new TikTokQuestionEvent(messageObject));
+        });
+
+        mapper.forMessage(WebcastLikeMessage.class, roomInfoHandler::handleLike);
+        mapper.forMessage(WebcastGiftMessage.class, giftHandler::handleGifts);
+        mapper.forMessage(WebcastSocialMessage.class, socialHandler::handle);
+        mapper.forMessage(WebcastMemberMessage.class, roomInfoHandler::handleMemberMessage);
+
+        //Host Interaction events
+        mapper.forMessage(WebcastPollMessage.class, commonHandler::handlePollEvent);
+        mapper.forMessage(WebcastRoomPinMessage.class, commonHandler::handlePinMessage);
+        mapper.forMessage(WebcastChatMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
+            return MappingResult.of(messageObject, new TikTokCommentEvent(messageObject));
+        });
+
+        //LinkMic events
+        mapper.forMessage(WebcastLinkMicBattle.class, (inputBytes, messageName, mapperHelper) -> {
+            var message = mapperHelper.bytesToWebcastObject(inputBytes, WebcastLinkMicBattle.class);
+            return MappingResult.of(message, new TikTokLinkMicBattleEvent(message));
+        });
+        mapper.forMessage(WebcastLinkMicArmies.class, (inputBytes, messageName, mapperHelper) -> {
+            var message = mapperHelper.bytesToWebcastObject(inputBytes, WebcastLinkMicArmies.class);
+            return MappingResult.of(message, new TikTokLinkMicArmiesEvent(message));
+        });
+        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);
+                case TYPE_LINKER_CREATE -> new TikTokLinkCreateEvent(message);
+                case TYPE_LINKER_CLOSE -> new TikTokLinkCloseEvent(message);
+                case TYPE_LINKER_ENTER -> new TikTokLinkEnterEvent(message);
+                case TYPE_LINKER_LEAVE -> new TikTokLinkLeaveEvent(message);
+                case TYPE_LINKER_CANCEL_INVITE, TYPE_LINKER_CANCEL_APPLY -> new TikTokLinkCancelEvent(message);
+                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_MUTE -> new TikTokLinkMuteEvent(message);
+                case TYPE_LINKER_MATCH -> new TikTokLinkRandomMatchEvent(message);
+                case TYPE_LINKER_UPDATE_USER_SETTING -> new TikTokLinkUpdateUserSettingEvent(message);
+                case TYPE_LINKER_MIC_IDX_UPDATE -> new TikTokLinkMicIdxUpdateEvent(message);
+                case TYPE_LINKER_LINKED_LIST_CHANGE_V2 -> new TikTokLinkListChangeEvent(message);
+                case TYPE_LINKER_COHOST_LIST_CHANGE -> new TikTokLinkCohostListChangeEvent(message);
+                case TYPE_LINKER_MEDIA_CHANGE -> new TikTokLinkMediaChangeEvent(message);
+                case TYPE_LINKER_ACCEPT_NOTICE -> new TikTokLinkAcceptNoticeEvent(message);
+                case TYPE_LINKER_SYS_KICK_OUT -> new TikTokLinkSysKickOutEvent(message);
+                case TYPE_LINKMIC_USER_TOAST -> new TikTokLinkUserToastEvent(message);
+                default -> new TikTokLinkEvent(message);
+            });
+        }));
+        // mapper.webcastObjectToConstructor(WebcastLinkMicMethod.class, TikTokLinkMicMethodEvent.class);
+        //  mapper.webcastObjectToConstructor(WebcastLinkMicFanTicketMethod.class, TikTokLinkMicFanTicketEvent.class);
+
+        //Rank events
+        //   mapper.webcastObjectToConstructor(WebcastRankTextMessage.class, TikTokRankTextEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastRankUpdateMessage.class, TikTokRankUpdateEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastHourlyRankMessage.class, TikTokRankUpdateEvent.class);
+
+        //Others events
+        //  mapper.webcastObjectToConstructor(WebcastInRoomBannerMessage.class, TikTokInRoomBannerEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastMsgDetectMessage.class, TikTokDetectEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastBarrageMessage.class, TikTokBarrageEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastUnauthorizedMemberMessage.class, TikTokUnauthorizedMemberEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastOecLiveShoppingMessage.class, TikTokShopEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastImDeleteMessage.class, TikTokIMDeleteEvent.class);
+        //  mapper.bytesToEvents(WebcastEnvelopeMessage.class, commonHandler::handleEnvelop);
+        return mapper;
+    }
+}

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

@@ -75,5 +75,4 @@ public class TikTokLiveMapperModel implements TikTokMapperModel {
         return this;
     }
 
-
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/handlers/TikTokChestEventHandler.java

@@ -1,26 +0,0 @@
-/*
- * Copyright (c) 2023-2023 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.mappers.handlers;
-
-public class TikTokChestEventHandler {
-}

Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/handlers/TikTokGiftEventHandler.java

@@ -27,13 +27,11 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.*;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.*;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.live.GiftsManager;
 import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
 import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import lombok.SneakyThrows;
-import sun.misc.Unsafe;
 
 import java.util.*;
 
@@ -58,40 +56,40 @@ public class TikTokGiftEventHandler {
 
     public List<TikTokEvent> handleGift(WebcastGiftMessage currentMessage) {
         var userId = currentMessage.getUser().getId();
-        var currentType = GiftSendType.fromNumber(currentMessage.getSendType());
+        var currentType = GiftComboStateType.fromNumber(currentMessage.getSendType());
         var containsPreviousMessage = giftsMessages.containsKey(userId);
 
 
         //If gift is not streakable just return onGift event
         if (currentMessage.getGift().getType() != 1) {
-            var comboEvent = getGiftComboEvent(currentMessage, GiftSendType.Finished);
+            var comboEvent = getGiftComboEvent(currentMessage, GiftComboStateType.Finished);
             var giftEvent = getGiftEvent(currentMessage);
             return List.of(comboEvent, giftEvent);
         }
 
         if (!containsPreviousMessage) {
-            if (currentType == GiftSendType.Finished) {
+            if (currentType == GiftComboStateType.Finished) {
                 return List.of(getGiftEvent(currentMessage));
             } else {
                 giftsMessages.put(userId, currentMessage);
-                return List.of(getGiftComboEvent(currentMessage, GiftSendType.Begin));
+                return List.of(getGiftComboEvent(currentMessage, GiftComboStateType.Begin));
             }
         }
 
         var previousMessage = giftsMessages.get(userId);
-        var previousType = GiftSendType.fromNumber(previousMessage.getSendType());
-        if (currentType == GiftSendType.Active &&
-                previousType == GiftSendType.Active) {
+        var previousType = GiftComboStateType.fromNumber(previousMessage.getSendType());
+        if (currentType == GiftComboStateType.Active &&
+                previousType == GiftComboStateType.Active) {
             giftsMessages.put(userId, currentMessage);
-            return List.of(getGiftComboEvent(currentMessage, GiftSendType.Active));
+            return List.of(getGiftComboEvent(currentMessage, GiftComboStateType.Active));
         }
 
 
-        if (currentType == GiftSendType.Finished &&
-                previousType == GiftSendType.Active) {
+        if (currentType == GiftComboStateType.Finished &&
+                previousType == GiftComboStateType.Active) {
             giftsMessages.clear();
             return List.of(
-                    getGiftComboEvent(currentMessage, GiftSendType.Finished),
+                    getGiftComboEvent(currentMessage, GiftComboStateType.Finished),
                     getGiftEvent(currentMessage));
         }
 
@@ -104,7 +102,7 @@ public class TikTokGiftEventHandler {
         return new TikTokGiftEvent(gift, tikTokRoomInfo.getHost(), message);
     }
 
-    private TikTokGiftEvent getGiftComboEvent(WebcastGiftMessage message, GiftSendType state) {
+    private TikTokGiftEvent getGiftComboEvent(WebcastGiftMessage message, GiftComboStateType state) {
         var gift = getGiftObject(message);
         return new TikTokGiftComboEvent(gift, tikTokRoomInfo.getHost(), message, state);
     }
@@ -124,36 +122,8 @@ public class TikTokGiftEventHandler {
         }
 
         if (gift.getPicture().getLink().endsWith(".webp"))
-        {
-            updatePicture(gift, giftMessage);
-        }
+            gift.setPicture(Picture.map(giftMessage.getGift().getImage()));
 
         return gift;
     }
-
-    // TODO-kohlerpop1: I do not think this method is needed for any reason?
-    // TODO response:
-
-    /**
-     * Some generated gifts in JSON file contains .webp image format,
-     * that's bad since java by the defult is not supporing .webp and when URL is
-     * converted to Java.io.Image then image is null
-     *
-     * However, TikTok in GiftWebcast event always has image in .jpg format,
-     * so I take advantage of it and swap .webp url with .jpg url
-     *
-     */
-
-    private void updatePicture(Gift gift, WebcastGiftMessage webcastGiftMessage) {
-        try {
-            var picture = Picture.map(webcastGiftMessage.getGift().getImage());
-            var constructor = Unsafe.class.getDeclaredConstructors()[0];
-            constructor.setAccessible(true);
-            var field = Gift.class.getDeclaredField("picture");
-            field.setAccessible(true);
-            field.set(gift, picture);
-        } catch (Exception e) {
-            throw new TikTokLiveException("Unable to update picture in gift: " + gift.toString());
-        }
-    }
 }

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

@@ -22,6 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.websocket;
 
+import io.github.jwdeveloper.dependance.injector.api.containers.Container;
 import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.dto.ProxyData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
@@ -63,7 +64,7 @@ public class TikTokWebSocketClient implements SocketClient {
 
         messageHandler.handle(liveClient, connectionData.getWebcastResponse());
 
-        var headers = new HashMap<String, String>();
+		var headers = new HashMap<>(clientSettings.getHttpSettings().getHeaders());
         headers.put("Cookie", connectionData.getWebsocketCookies());
         webSocketClient = new TikTokWebSocketListener(connectionData.getWebsocketUrl(),
                 headers,
@@ -82,7 +83,7 @@ public class TikTokWebSocketClient implements SocketClient {
     private void connectDefault() {
         try {
             webSocketClient.connect();
-            pingingTask.run(webSocketClient);
+            pingingTask.run(webSocketClient, clientSettings.getPingInterval());
             isConnected = true;
         } catch (Exception e) {
             isConnected = false;
@@ -112,7 +113,7 @@ public class TikTokWebSocketClient implements SocketClient {
                     proxySettings.remove();
                 continue;
             }
-            pingingTask.run(webSocketClient);
+            pingingTask.run(webSocketClient, clientSettings.getPingInterval());
             isConnected = true;
             break;
         }

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

@@ -61,7 +61,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
         } catch (Exception e) {
             tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(e));
         }
-        if (isNotClosing()) {
+        if (isOpen()) {
             sendPing();
         }
     }
@@ -79,8 +79,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
             pushFrameBuilder.setPayloadType("ack");
             pushFrameBuilder.setLogId(websocketPushFrame.getLogId());
             pushFrameBuilder.setPayload(webcastResponse.getInternalExtBytes());
-            if (isNotClosing())
-            {
+            if (isOpen()) {
                 this.send(pushFrameBuilder.build().toByteArray());
             }
         }
@@ -90,7 +89,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
     @Override
     public void onOpen(ServerHandshake serverHandshake) {
         tikTokEventHandler.publish(tikTokLiveClient, new TikTokConnectedEvent());
-        if (isNotClosing()) {
+        if (isOpen()) {
             sendPing();
         }
     }
@@ -104,7 +103,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
     @Override
     public void onError(Exception error) {
         tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(error));
-        if (isNotClosing()) {
+        if (isOpen()) {
             sendPing();
         }
     }
@@ -129,10 +128,6 @@ public class TikTokWebSocketListener extends WebSocketClient {
         }
     }
 
-    private boolean isNotClosing() {
-        return !isClosed() && !isClosing();
-    }
-
     @Override
     public void onMessage(String s) {
         // System.err.println(s);