- fix tests

- User.name was empty in testing event
- Add `onConnecting` to builder

API/pom.xml

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

API/src/main/java/io/github/jwdeveloper/tiktok/annotations/Priority.java

@@ -0,0 +1,18 @@
+package io.github.jwdeveloper.tiktok.annotations;
+
+/**
+ * HIGHEST 1
+ * HIGH 2
+ * NORMAL 3
+ * LOW 4
+ * LOWEST 5
+ */
+public enum Priority {
+    LOWEST(2), LOW(1), NORMAL(0), HIGH(-1), HIGHEST(-2);
+
+    public final int value;
+
+    Priority(int value) {
+        this.value = value;
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/annotations/TikTokEventObserver.java

@@ -28,5 +28,14 @@ import java.lang.annotation.RetentionPolicy;
 @Retention(RetentionPolicy.RUNTIME)
 public @interface TikTokEventObserver
 {
+    /**
+     * When more than one method listen for certain Event, you can specify the method priority
+     * @see Priority
+     */
+    Priority priority() default Priority.NORMAL;
 
+    /**
+     * When true, action is invoked on a thread, from the threads pool
+     */
+    boolean async() default false;
 }

API/src/main/java/io/github/jwdeveloper/tiktok/data/dto/ProxyData.java

@@ -50,16 +50,12 @@ public class ProxyData
 
 			return new ProxyData(address, port);
 		} catch (NumberFormatException e) {
-			throw new IllegalArgumentException("Port must be a valid integer!");
+			throw new IllegalArgumentException("Port must be a valid integer!", e);
 		} catch (UnknownHostException e) {
-			throw new IllegalArgumentException("Address must be valid IPv4, IPv6, or domain name!");
+			throw new IllegalArgumentException("Address must be valid IPv4, IPv6, or domain name!", e);
 		}
 	}
 
-	public ProxyData clone() {
-		return new ProxyData(address, port);
-	}
-
 	public InetSocketAddress toSocketAddress() {
 		return new InetSocketAddress(address, port);
 	}

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

@@ -32,9 +32,7 @@ import lombok.Getter;
 
 import java.util.List;
 
-/**
- * Triggered every time a new chat comment arrives.
- */
+
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokCommentEvent extends TikTokHeaderEvent {
@@ -60,6 +58,7 @@ public class TikTokCommentEvent extends TikTokHeaderEvent {
         var builder = WebcastChatMessage.newBuilder();
         builder.setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
                 .setNickname(userName)
+                .setDisplayId(userName)
                 .build());
         builder.setContentLanguage("en");
         builder.setVisibleToSender(true);

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

@@ -25,11 +25,13 @@ import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
 
-/**
- * Triggered when the connection is successfully established.
- */
 @EventMeta(eventType = EventType.Control)
 public class TikTokConnectedEvent extends TikTokLiveClientEvent
 {
 
+
+    public static TikTokConnectedEvent of()
+    {
+        return new TikTokConnectedEvent();
+    }
 }

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

@@ -26,10 +26,7 @@ import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
 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 {
@@ -42,4 +39,10 @@ public class TikTokDisconnectedEvent extends TikTokLiveClientEvent {
 	public TikTokDisconnectedEvent() {
 		this("None");
 	}
+
+
+	public static TikTokDisconnectedEvent of(String reason)
+	{
+		return new TikTokDisconnectedEvent(reason);
+	}
 }

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

@@ -25,16 +25,18 @@ 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.data.events.common.TikTokLiveClientEvent;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
-/**
- * General error event. You should handle this.
- */
 @Getter
 @AllArgsConstructor
 @EventMeta(eventType = EventType.Control)
-public class TikTokErrorEvent extends TikTokLiveClientEvent
-{
+public class TikTokErrorEvent extends TikTokLiveClientEvent {
     private final Throwable exception;
+
+
+    public static TikTokErrorEvent of(String message) {
+        return new TikTokErrorEvent(new TikTokLiveException(message));
+    }
 }

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

@@ -43,8 +43,6 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
      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) {
@@ -55,7 +53,6 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
         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));
@@ -64,7 +61,6 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
                 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:
@@ -74,10 +70,14 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
     }
 
     public boolean is1v1() {
-        return oneVsOne;
+        return teams.get(0) instanceof Team1v1;
     }
 
     public boolean is2v2() {
-        return !oneVsOne;
+        return teams.get(0) instanceof Team2v2;
+    }
+
+    public boolean isTie() {
+        return isFinished() && teams.get(0).getTotalPoints() == teams.get(1).getTotalPoints();
     }
 }

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

@@ -24,11 +24,14 @@ 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.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.control.TikTokConnectingEvent;
 
 
-/**
- * Triggered when the live stream gets terminated by the host. Will also trigger the TikTokDisconnectedEvent event.
- */
 @EventMeta(eventType = EventType.Message)
 public class TikTokLiveEndedEvent extends TikTokEvent {
+
+
+    public static TikTokLiveEndedEvent of() {
+        return new TikTokLiveEndedEvent();
+    }
 }

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

@@ -29,9 +29,7 @@ import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastQuestionNewMessage;
 import lombok.Getter;
 
-/*
-Triggered every time someone asks a new question via the question feature.
- */
+
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokQuestionEvent extends TikTokHeaderEvent {

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

@@ -31,9 +31,7 @@ import io.github.jwdeveloper.tiktok.messages.webcast.WebcastMemberMessage;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSubNotifyMessage;
 import lombok.Getter;
 
-/**
- * Triggers when a user creates a subscription.
- */
+
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokSubscribeEvent extends TikTokHeaderEvent {
@@ -55,6 +53,7 @@ public class TikTokSubscribeEvent extends TikTokHeaderEvent {
     public static TikTokSubscribeEvent of(String userName) {
         return new TikTokSubscribeEvent(WebcastMemberMessage.newBuilder()
                 .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setDisplayId(userName)
                         .setNickname(userName)
                         .build())
                 .build());

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

@@ -26,9 +26,6 @@ package io.github.jwdeveloper.tiktok.data.events.common;
 import io.github.jwdeveloper.tiktok.utils.JsonUtil;
 import lombok.Getter;
 
-/**
- * Base class for all events
- */
 @Getter
 public abstract class TikTokEvent {
 

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

@@ -31,7 +31,9 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
  * Triggered when client is connecting to live is successfully established.
  */
 @EventMeta(eventType = EventType.Control)
-public class TikTokConnectingEvent extends TikTokLiveClientEvent
-{
+public class TikTokConnectingEvent extends TikTokLiveClientEvent {
 
+    public static TikTokConnectingEvent of() {
+        return new TikTokConnectingEvent();
+    }
 }

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

@@ -27,9 +27,7 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
 import io.github.jwdeveloper.tiktok.data.requests.*;
 import lombok.*;
 
-/**
- * Triggered before the connection is established.
- */
+
 @Getter
 @EventMeta(eventType = EventType.Control)
 public class TikTokPreConnectionEvent extends TikTokLiveClientEvent

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

@@ -29,20 +29,6 @@ import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import lombok.Getter;
 
-
-/**
- * Triggered every time gift is sent
- *
- * @see GiftComboStateType it has 3 states
- *
- * <p>Example when user sends gift with combo</p>
- * <p>>Combo: 1  -> comboState = GiftSendType.Begin</p>
- * <p>Combo: 4 -> comboState = GiftSendType.Active</p>
- * <p>Combo: 8 -> comboState = GiftSendType.Active</p>
- * <p>Combo: 12 -> comboState = GiftSendType.Finsihed</p>
- * <p>
- * Remember if comboState is Finsihed both TikTokGiftComboEvent and TikTokGiftEvent event gets triggered
- */
 @EventMeta(eventType = EventType.Message)
 @Getter
 public class TikTokGiftComboEvent extends TikTokGiftEvent {
@@ -55,12 +41,9 @@ public class TikTokGiftComboEvent extends TikTokGiftEvent {
 
     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);
+            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

@@ -22,7 +22,6 @@
  */
 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;
@@ -31,12 +30,6 @@ import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import lombok.Getter;
 
-
-/**
- * Triggered when user sends gifts that has
- * no combo (most of expensive gifts)
- * or if combo has finished
- */
 @EventMeta(eventType = EventType.Message)
 @Getter
 public class TikTokGiftEvent extends TikTokHeaderEvent {

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

@@ -1,38 +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.data.events.http;
-
-import io.github.jwdeveloper.tiktok.annotations.EventMeta;
-import io.github.jwdeveloper.tiktok.annotations.EventType;
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.data.requests.LiveData;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-@EventMeta(eventType = EventType.Debug)
-public class TikTokRoomDataResponseEvent extends TikTokEvent
-{
-    private final LiveData.Response liveData;
-}

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

@@ -30,9 +30,7 @@ import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 
-/**
-Triggered when LiveRoomInfo got updated such as likes, viewers, ranking ....
- */
+
 @Getter
 @AllArgsConstructor
 @EventMeta(eventType = EventType.Message)

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

@@ -29,13 +29,10 @@ import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSocialMessage;
 import lombok.Value;
 
-/**
- * Triggers when a user follows the streamer. Based on social event.
- */
+
 @Value
 @EventMeta(eventType = EventType.Message)
-public class TikTokFollowEvent extends TikTokHeaderEvent
-{
+public class TikTokFollowEvent extends TikTokHeaderEvent {
     User user;
     int totalFollowers;
 
@@ -45,12 +42,12 @@ public class TikTokFollowEvent extends TikTokHeaderEvent
         totalFollowers = msg.getFollowCount();
     }
 
-    public static TikTokFollowEvent of(String userName)
-    {
+    public static TikTokFollowEvent of(String userName) {
         return new TikTokFollowEvent(WebcastSocialMessage.newBuilder()
-            .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
-                .setNickname(userName)
-                .build())
-            .build());
+                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setDisplayId(userName)
+                        .setNickname(userName)
+                        .build())
+                .build());
     }
 }

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

@@ -53,6 +53,7 @@ public class TikTokJoinEvent extends TikTokHeaderEvent {
     {
         return new TikTokJoinEvent(WebcastMemberMessage.newBuilder()
                 .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setDisplayId(userName)
                         .setNickname(userName)
                         .build())
                 .build());

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

@@ -31,9 +31,7 @@ import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSocialMessage;
 import lombok.Getter;
 
 
-/**
- * Triggered when a viewer sends likes to the streamer. For streams with many viewers, this event is not always triggered by TikTok.
- */
+
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokLikeEvent extends TikTokHeaderEvent
@@ -64,6 +62,7 @@ public class TikTokLikeEvent extends TikTokHeaderEvent
                 .setCount(likes)
                 .setTotal(likes)
                 .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setDisplayId(userName)
                         .setNickname(userName)
                         .build())
                 .build());

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

@@ -26,27 +26,35 @@ 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.WebcastSocialMessage;
 import lombok.Getter;
 
-/**
- * Triggers when a user shares the stream. Based on social event.
- */
+
 @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;
+    }
+
+    public static TikTokShareEvent of(String userName, int shaders) {
+        return new TikTokShareEvent(WebcastSocialMessage.newBuilder()
+                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
+                        .setDisplayId(userName)
+                        .setNickname(userName)
+                        .build())
+                .build(), shaders);
+    }
 }

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

@@ -35,10 +35,7 @@ import lombok.Value;
 import java.time.Duration;
 
 
-/**
- * Triggered every time TikTok sends data. Data incoming as protobuf message.
- * You can deserialize the binary object depending on the use case.
- */
+
 @Getter
 @AllArgsConstructor
 @EventMeta(eventType = EventType.Debug)

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

@@ -29,9 +29,7 @@ import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 import lombok.Getter;
 
 
-/**
- * Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
- */
+
 @Getter
 @EventMeta(eventType = EventType.Debug)
 public class TikTokWebsocketUnhandledMessageEvent extends TikTokUnhandledEvent<WebcastResponse.Message>

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

@@ -1,6 +1,33 @@
+/*
+ * 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 lombok.Getter;
+
 public abstract class Team {
+    /** Value >= 0 when finished otherwise -1 */
+    @Getter protected int totalPoints;
+
     /**
      * Provides a check for verifying if this team represents a 1v1 Team.
      * @return true if this team is of type {@link Team1v1}, false otherwise.

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Team1v1.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.data.models.battles;
 
 import io.github.jwdeveloper.tiktok.data.models.users.User;
@@ -7,10 +29,7 @@ import lombok.Getter;
 import java.util.*;
 
 @Getter
-public class Team1v1 extends Team
-{
-    /** Value >= 0 when finished otherwise -1 */
-    private final int totalPoints;
+public class Team1v1 extends Team {
     private final int winStreak;
     private final User host;
     private final List<Viewer> viewers;

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Team2v2.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.data.models.battles;
 
 import io.github.jwdeveloper.tiktok.data.models.users.User;
@@ -8,9 +30,6 @@ 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;
 

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Viewer.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.data.models.battles;
 
 import io.github.jwdeveloper.tiktok.data.models.Picture;

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/gifts/Gift.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.data.models.gifts;
 
 import com.google.gson.JsonObject;

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

@@ -23,9 +23,9 @@
 package io.github.jwdeveloper.tiktok.data.models.gifts;
 
 public enum GiftComboStateType {
-    Finished,
     Begin,
-    Active;
+    Active,
+    Finished;
 
     public static GiftComboStateType fromNumber(long number) {
         return switch ((int) number) {

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/users/ListUser.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.data.models.users;
 
 import lombok.Getter;
@@ -31,4 +53,19 @@ public class ListUser
         AUDIO,
         VIDEO
     }
+
+    @Override
+    public String toString() {
+        return "ListUser{" +
+            "user=" + user +
+            ", linkType=" + linkType +
+            ", linkMicId=" + linkMicId +
+            ", linkStatus=" + linkStatus +
+            ", modifyTime=" + modifyTime +
+            ", linkerId=" + linkerId +
+            ", userPosition=" + userPosition +
+            ", silenceStatus=" + silenceStatus +
+            ", roleType=" + roleType +
+            "}";
+    }
 }

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

@@ -22,16 +22,12 @@
  */
 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.data.models.badges.Badge;
 import io.github.jwdeveloper.tiktok.messages.webcast.*;
-import lombok.AccessLevel;
-import lombok.Getter;
+import lombok.*;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 @Getter
 public class User {
@@ -49,12 +45,12 @@ public class User {
         return attributes.stream().toList();
     }
 
-    public boolean hasAttribute(UserAttribute userFlag) {
-        return attributes.contains(userFlag);
+    public boolean hasAttribute(UserAttribute attribute) {
+        return attributes.contains(attribute);
     }
 
-    public void addAttribute(UserAttribute... flags) {
-        this.attributes.addAll(Arrays.stream(flags).toList());
+    public void addAttribute(UserAttribute... attributes) {
+        this.attributes.addAll(List.of(attributes));
     }
 
     public boolean isGiftGiver() {
@@ -168,11 +164,11 @@ public class User {
     }
 
     public static User EMPTY = new User(0L,
-            "",
-            Picture.empty(),
-            0,
-            0,
-            List.of(Badge.empty()));
+        "",
+        Picture.empty(),
+        0,
+        0,
+        List.of(Badge.empty()));
 
     public static User map(io.github.jwdeveloper.tiktok.messages.data.User user) {
         return new User(user);
@@ -209,12 +205,12 @@ public class User {
 
     public static User map(WebcastEnvelopeMessage.EnvelopeInfo envelopeInfo) {
         return new User(0L,
-                //envelopeInfo.getSendUserId(),
-                envelopeInfo.getSendUserName(),
-                Picture.map(envelopeInfo.getSendUserAvatar()),
-                0,
-                0,
-                List.of(Badge.empty()));
+            //envelopeInfo.getSendUserId(),
+            envelopeInfo.getSendUserName(),
+            Picture.map(envelopeInfo.getSendUserAvatar()),
+            0,
+            0,
+            List.of(Badge.empty()));
     }
 
     @Override

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

@@ -27,18 +27,23 @@ import lombok.*;
 public class LiveUserData {
 
     @Getter
-    @AllArgsConstructor
     public static class Request {
-        private String userName;
+        private final String userName;
+
+        public Request(String userName) {
+            if (userName == null || userName.isBlank())
+                throw new IllegalArgumentException("Invalid empty username!");
+            this.userName = userName;
+        }
     }
 
     @Getter
     @AllArgsConstructor
     public static class Response {
-        private String json;
-        private UserStatus userStatus;
-        private String roomId;
-        private long startedAtTimeStamp;
+        private final String json;
+        private final UserStatus userStatus;
+        private final String roomId;
+        private final long startTime;
 
         public boolean isLiveOnline() {
             return userStatus == LiveUserData.UserStatus.Live || userStatus == LiveUserData.UserStatus.LivePaused;

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

@@ -97,7 +97,7 @@ public class HttpClientSettings {
         newSettings.getHeaders().putAll(new TreeMap<>(this.headers));
         newSettings.getCookies().putAll(new TreeMap<>(this.cookies));
         newSettings.getParams().putAll(new TreeMap<>(this.params));
-        newSettings.proxyClientSettings = this.proxyClientSettings;
+        newSettings.setProxyClientSettings(this.proxyClientSettings);
 
         return newSettings;
     }

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

@@ -31,17 +31,17 @@ 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;
     private final List<ProxyData> proxyList = new ArrayList<>();
-    private int index = -1;
+    private int index;
     private Proxy.Type type = Proxy.Type.DIRECT;
     private Consumer<ProxyData> onProxyUpdated = x -> {};
 
     public boolean addProxy(String addressPort) {
-        return proxyList.add(ProxyData.map(addressPort));
+        return addProxy(ProxyData.map(addressPort).toSocketAddress());
     }
 
     public boolean addProxy(String address, int port) {
@@ -57,33 +57,27 @@ public class ProxyClientSettings implements Iterator<ProxyData>
     }
 
     @Override
-    public boolean hasNext() {
+    public synchronized boolean hasNext() {
         return !proxyList.isEmpty();
     }
 
     @Override
-    public ProxyData next() {
-        var nextProxy = switch (rotation)
-        {
-            case CONSECUTIVE -> {
-                index = (index+1) % proxyList.size();
-                yield proxyList.get(index).clone();
+    public synchronized ProxyData next() {
+        try {
+            var nextProxy = proxyList.get(index);
+            onProxyUpdated.accept(nextProxy);
+            return nextProxy;
+        } finally {
+            switch (rotation) {
+                case CONSECUTIVE -> index = ++index % proxyList.size();
+                case RANDOM -> index = (int) (Math.random() * proxyList.size());
+                case NONE -> index = Math.max(index, 0);
             }
-            case RANDOM -> {
-                index = new Random().nextInt(proxyList.size());
-                yield proxyList.get(index).clone();
-            }
-            case NONE -> {
-                index = Math.max(index, 0);
-                yield proxyList.get(index).clone();
-            }
-        };
-        onProxyUpdated.accept(nextProxy);
-        return nextProxy;
-	}
+        }
+    }
 
     @Override
-    public void remove() {
+    public synchronized void remove() {
         proxyList.remove(index);
     }
 
@@ -97,8 +91,8 @@ public class ProxyClientSettings implements Iterator<ProxyData>
         }
     }
 
-    public ProxyClientSettings clone()
-    {
+    @Override
+    public ProxyClientSettings clone() {
         ProxyClientSettings settings = new ProxyClientSettings();
         settings.setEnabled(enabled);
         settings.setRotation(rotation);
@@ -109,6 +103,27 @@ public class ProxyClientSettings implements Iterator<ProxyData>
         return settings;
     }
 
+    @Override
+    public String toString() {
+        return "ProxyClientSettings{" +
+            "enabled=" + enabled +
+            ", autoDiscard=" + autoDiscard +
+            ", fallback=" + fallback +
+            ", rotation=" + rotation +
+            ", proxyList=" + proxyList +
+            ", index=" + index +
+            ", type=" + type +
+            '}';
+    }
+
+    /**
+     * With {@code Iterable<ProxyData>} 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/exceptions/TikTokLiveUnknownHostException.java

@@ -20,7 +20,11 @@
  * 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;
+package io.github.jwdeveloper.tiktok.exceptions;
 
-public class TikTokChestEventHandler {
-}
+public class TikTokLiveUnknownHostException extends TikTokLiveException
+{
+    public TikTokLiveUnknownHostException(String message) {
+        super(message);
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/handler/TikTokMessageHandler.java

@@ -1,34 +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.handler;
-
-
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-
-import java.util.List;
-
-
-public interface TikTokMessageHandler
-{
-    List<TikTokEvent> handle(byte[] messagePayload) throws Exception;
-}

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

@@ -25,15 +25,13 @@ package io.github.jwdeveloper.tiktok.listener;
 import java.util.List;
 
 /**
- *  You can dynamically add or removing TikTokEventListener
- *
- * @see TikTokEventListener
- *
+ *  Manage events listeners objects
  */
 public interface ListenersManager
 {
-    List<TikTokEventListener> getListeners();
-    void addListener(TikTokEventListener listener);
+    List<Object> getListeners();
 
-    void removeListener(TikTokEventListener listener);
+    void addListener(Object listener);
+
+    void removeListener(Object listener);
 }

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

@@ -40,7 +40,7 @@ import io.github.jwdeveloper.tiktok.live.LiveClient;
  * {@code
  * 	public static class CustomListener implements TikTokEventListener
  *  {
- *  	@TikTokEventObserver
+ *    @TikTokEventObserver
  *      public void onError(LiveClient liveClient, TikTokErrorEvent event)
  *      {
  *      	System.out.println(event.getException().getMessage());
@@ -67,7 +67,9 @@ import io.github.jwdeveloper.tiktok.live.LiveClient;
  *  }
  *  </pre>
  */
-public interface TikTokEventListener
-{
+//TODO I think this interface can be removed, since we are using,
+//annotation @TikTokEventHandler to check methods that are events
+@Deprecated(forRemoval = true, since = "1.8.1 (This interface is not longer needed, please remove it from your class)")
+public interface TikTokEventListener {
 
 }

API/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokEventListenerBase.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.listener;
 
 import io.github.jwdeveloper.tiktok.data.events.*;

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

@@ -0,0 +1,19 @@
+package io.github.jwdeveloper.tiktok.live;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
+
+import java.util.HashSet;
+import java.util.Optional;
+
+public interface LiveEventsHandler {
+    void publish(LiveClient tikTokLiveClient, TikTokEvent tikTokEvent);
+
+    <T extends TikTokEvent> void subscribe(Class<?> clazz, EventConsumer<T> event);
+
+    <T extends TikTokEvent> void unsubscribeAll(Class<?> clazz);
+
+    <T extends TikTokEvent> void unsubscribe(EventConsumer<T> consumer);
+
+    <T extends TikTokEvent> void unsubscribe(Class<?> clazz, EventConsumer<T> consumer);
+}

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

@@ -0,0 +1,18 @@
+package io.github.jwdeveloper.tiktok.live;
+
+import io.github.jwdeveloper.tiktok.data.dto.MessageMetaData;
+import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
+import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketMessageEvent;
+import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketResponseEvent;
+import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandledMessageEvent;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageException;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
+import io.github.jwdeveloper.tiktok.utils.Stopwatch;
+
+import java.time.Duration;
+
+public interface LiveMessagesHandler {
+    void handle(LiveClient client, WebcastResponse webcastResponse);
+
+    void handleSingleMessage(LiveClient client, WebcastResponse.Message message);
+}

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

@@ -25,7 +25,13 @@ 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>
 {
+     /**
+      *
+      * @param liveClient TikTok live client
+      * @param event event data object
+      */
      void onEvent(LiveClient liveClient, T event);
 }

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

@@ -22,8 +22,9 @@
  */
 package io.github.jwdeveloper.tiktok.live.builder;
 
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.*;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.control.TikTokConnectingEvent;
 import io.github.jwdeveloper.tiktok.data.events.control.TikTokPreConnectionEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
@@ -36,6 +37,7 @@ import io.github.jwdeveloper.tiktok.data.events.social.TikTokShareEvent;
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketMessageEvent;
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketResponseEvent;
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandledMessageEvent;
+import io.github.jwdeveloper.tiktok.data.models.gifts.GiftComboStateType;
 
 
 public interface EventsBuilder<T> {
@@ -52,131 +54,269 @@ public interface EventsBuilder<T> {
     /**
      * Invoked whenever any event is triggered
      *
-     * @param action
-     * @return
+     * @param action consumable action
+     * @return self instance
      */
-    T onEvent(EventConsumer<TikTokEvent> action);
+    default T onEvent(EventConsumer<TikTokEvent> action) {
+        return onEvent(TikTokEvent.class, action);
+    }
+
+
+    /**
+     * As a first event after method `LiveClient::connect()` is performed
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onConnecting(EventConsumer<TikTokConnectingEvent> action)
+    {
+        return onEvent(TikTokConnectingEvent.class, action);
+    }
 
     /**
      * Invoked when information about room (live) got updated such as viewer count, etc..
      *
-     * @param action
-     * @return
+     * @param action consumable action
+     * @return self instance
      */
-    T onRoomInfo(EventConsumer<TikTokRoomInfoEvent> action);
+    default T onRoomInfo(EventConsumer<TikTokRoomInfoEvent> action) {
+        return onEvent(TikTokRoomInfoEvent.class, action);
+    }
 
     /**
      * Invoked when someone send message to chat
      *
-     * @param action
-     * @return
+     * @param action consumable action
+     * @return self instance
      */
-    T onComment(EventConsumer<TikTokCommentEvent> action);
-
+    default T onComment(EventConsumer<TikTokCommentEvent> action) {
+        return onEvent(TikTokCommentEvent.class, action);
+    }
 
     /**
      * Invoked when TikTokLiveJava makes http request and getting response
      *
-     * @param action
-     * @return
+     * @param action consumable action
+     * @return self instance
      */
-    T onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action);
+    default T onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
+        return onEvent(TikTokHttpResponseEvent.class, action);
+    }
 
     /**
      * Invoked when TikTok protocolBuffer data "message" was successfully mapped to event
      * events contains protocol-buffer "Message"  and  TikTokLiveJava "Event"
      *
-     * @param action
-     * @return
+     * @param action consumable action
+     * @return self instance
      */
-    T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> action);
+    default T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> action) {
+        return onEvent(TikTokWebsocketMessageEvent.class, action);
+    }
 
     /**
-     * Invoked when there was not found event mapper for TikTok protocolBuffer data "message"
+     * Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
      *
-     * @param action
-     * @return
+     * @param action consumable action
+     * @return self instance
      */
-    T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> action);
+    default T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> action) {
+        return onEvent(TikTokWebsocketUnhandledMessageEvent.class, action);
+    }
 
     /**
      * Invoked every time TikTok sends protocolBuffer data to websocket
      * Response contains list of messages that are later mapped to events
-     * @param action
-     * @return
+     *
+     * @param action consumable action
+     * @return self instance
      */
-    T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> action);
-
+    default T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> action) {
+        return onEvent(TikTokWebsocketResponseEvent.class, action);
+    }
 
     /**
-     * Invoked for gifts that has no combo, or when combo finishes
-     * @param action
-     * @return
+     * Triggers for these different reasons:
+     * <ol>
+     *     <li>User sends gifts that have no combo (most of expensive gifts)</li>
+     *     <li>{@link TikTokGiftComboEvent} has combaState = {@link GiftComboStateType#Finished}</li>
+     * </ol>
+     * @param action consumable action
+     * @return self instance
      */
-    T onGift(EventConsumer<TikTokGiftEvent> action);
+    default T onGift(EventConsumer<TikTokGiftEvent> action) {
+        return onEvent(TikTokGiftEvent.class, action);
+    }
 
     /**
-     * Invoked for gifts that has combo options such as roses
-     * @param action
-     * @return
+     * Triggered every time a gift is sent
+     * <p>Example when user sends gift with combo</p>
+     * <ul>
+     *     <li>Combo: 1  -> comboState = {@link GiftComboStateType#Begin}</li>
+     *     <li>Combo: 4 -> comboState = {@link GiftComboStateType#Active}</li>
+     *     <li>Combo: 8 -> comboState = {@link GiftComboStateType#Active}</li>
+     *     <li>Combo: 12 -> comboState = {@link GiftComboStateType#Finished}</li>
+     * </ul>
+     * Both {@link TikTokGiftComboEvent} and {@link TikTokGiftEvent} events are triggered when comboState is Finished
+     *
+     * @apiNote {@link GiftComboStateType} has 3 states: {@link GiftComboStateType#Begin Begin}, {@link GiftComboStateType#Active Active}, & {@link GiftComboStateType#Finished Finished}
+     * @param action consumable action
+     * @return self instance
      */
-    T onGiftCombo(EventConsumer<TikTokGiftComboEvent> action);
+    default T onGiftCombo(EventConsumer<TikTokGiftComboEvent> action) {
+        return onEvent(TikTokGiftComboEvent.class, action);
+    }
 
+    /**
+     * Triggered every time someone asks a new question via the question feature.
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onQuestion(EventConsumer<TikTokQuestionEvent> action) {
+        return onEvent(TikTokQuestionEvent.class, action);
+    }
 
-    T onQuestion(EventConsumer<TikTokQuestionEvent> action);
+    /**
+     * Triggers when a user subscribe the streamer.
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onSubscribe(EventConsumer<TikTokSubscribeEvent> action) {
+        return onEvent(TikTokSubscribeEvent.class, action);
+    }
 
-    T onSubscribe(EventConsumer<TikTokSubscribeEvent> action);
+    /**
+     * Triggers when a user follows the streamer. Based on social event.
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onFollow(EventConsumer<TikTokFollowEvent> action) {
+        return onEvent(TikTokFollowEvent.class, action);
+    }
 
-    T onFollow(EventConsumer<TikTokFollowEvent> action);
+    /**
+     * Triggered when a viewer sends likes to the streamer. For streams with many viewers, this event is not always triggered by TikTok.
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onLike(EventConsumer<TikTokLikeEvent> action) {
+        return onEvent(TikTokLikeEvent.class, action);
+    }
 
-    T onLike(EventConsumer<TikTokLikeEvent> action);
+    /**
+     * Triggers when a user sends emote
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onEmote(EventConsumer<TikTokEmoteEvent> action) {
+        return onEvent(TikTokEmoteEvent.class, action);
+    }
 
-    T onEmote(EventConsumer<TikTokEmoteEvent> action);
+    /**
+     * Triggers when a user joins to the live
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onJoin(EventConsumer<TikTokJoinEvent> action) {
+        return onEvent(TikTokJoinEvent.class, action);
+    }
 
-    T onJoin(EventConsumer<TikTokJoinEvent> action);
+    /**
+     * Triggers when a user shares the stream.
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onShare(EventConsumer<TikTokShareEvent> action) {
+        return onEvent(TikTokShareEvent.class, action);
+    }
 
-    T onShare(EventConsumer<TikTokShareEvent> action);
+    /**
+     * Triggered when the live stream gets paused
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onLivePaused(EventConsumer<TikTokLivePausedEvent> action) {
+        return onEvent(TikTokLivePausedEvent.class, action);
+    }
 
-    T onLivePaused(EventConsumer<TikTokLivePausedEvent> action);
+    /**
+     * Triggered when the live stream gets unpaused
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> action) {
+        return onEvent(TikTokLiveUnpausedEvent.class, action);
+    }
 
-    T onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> action);
-
-    T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> action);
+    /**
+     * Triggered when the live stream gets terminated by the host. Will also trigger the TikTokDisconnectedEvent event.
+     *
+     * @param action consumable action
+     * @return self instance
+     */
+    default T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> action) {
+        return onEvent(TikTokLiveEndedEvent.class, action);
+    }
 
     /**
      * Invoked when client has been successfully connected to live
-     * @param action
-     * @return
+     *
+     * @param action consumable action
+     * @return self instance
      */
-    T onConnected(EventConsumer<TikTokConnectedEvent> action);
+    default T onConnected(EventConsumer<TikTokConnectedEvent> action) {
+        return onEvent(TikTokConnectedEvent.class, action);
+    }
 
     /**
      * Invoked before client has been successfully connected to live
-     * @param action
-     * @return
+     *
+     * @param action consumable action
+     * @return self instance
      */
-    T onPreConnection(EventConsumer<TikTokPreConnectionEvent> action);
+    default T onPreConnection(EventConsumer<TikTokPreConnectionEvent> action) {
+        return onEvent(TikTokPreConnectionEvent.class, action);
+    }
 
     /**
      * Invoked when client tries to reconnect
-     * @param action
-     * @return
+     *
+     * @param action consumable action
+     * @return self instance
      */
-    T onReconnecting(EventConsumer<TikTokReconnectingEvent> action);
+    default T onReconnecting(EventConsumer<TikTokReconnectingEvent> action) {
+        return onEvent(TikTokReconnectingEvent.class, action);
+    }
 
     /**
-     * Invoked when client disconnected
-     * @param action
-     * @return
+     * 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 avoid being rate-limited.
+     *
+     * @param action consumable action
+     * @return self instance
      */
-    T onDisconnected(EventConsumer<TikTokDisconnectedEvent> action);
+    default T onDisconnected(EventConsumer<TikTokDisconnectedEvent> action) {
+        return onEvent(TikTokDisconnectedEvent.class, action);
+    }
 
     /**
      * Invoked when exception was throed inside client or event handler
-     * @param action
-     * @return
+     *
+     * @param action consumable action
+     * @return self instance
      */
-    T onError(EventConsumer<TikTokErrorEvent> action);
+    default T onError(EventConsumer<TikTokErrorEvent> action) {
+        return onEvent(TikTokErrorEvent.class, action);
+    }
 
 
     // TODO Figure out how those events works
@@ -223,4 +363,10 @@ public interface EventsBuilder<T> {
     //T onLinkMicBattle(TikTokEventConsumer<TikTokLinkMicBattleEvent> event);
 
     //T onUnhandledControl(TikTokEventConsumer<TikTokUnhandledControlEvent> event);
+
+    /**
+     * To do figure out how to use Annotation processor.
+     * Goal is to generates methods for all possible events, everytime library is compiled
+     */
+
 }

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

@@ -22,58 +22,73 @@
  */
 package io.github.jwdeveloper.tiktok.live.builder;
 
+import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
 import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
-import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.mappers.TikTokMapper;
+import io.github.jwdeveloper.tiktok.mappers.LiveMapper;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 
 public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
 
+
     /**
      * This method is triggered after default mappings are registered
      * It could be used to OVERRIDE behaviour of mappings and implement custom behaviour
-     *
+     * <p>
      * Be aware if for example you override WebcastGiftEvent, onGiftEvent() will not be working
      *
      * @param onCustomMappings lambda method
      * @return
      */
-    LiveClientBuilder onMapping(Consumer<TikTokMapper> onCustomMappings);
+    LiveClientBuilder mappings(Consumer<LiveMapper> onCustomMappings);
 
+    @Deprecated(forRemoval = true, since = "1.8.2 use `mappings` method instead")
+    LiveClientBuilder onMappings(Consumer<LiveMapper> onCustomMappings);
 
     /**
      * Configuration of client settings
-     * @see LiveClientSettings
+     *
      * @param onConfigure
      * @return
+     * @see LiveClientSettings
      */
     LiveClientBuilder configure(Consumer<LiveClientSettings> onConfigure);
 
     /**
-     * @see TikTokEventListener
      * Adding events listener class, its fancy way to register events without using lamda method
      * but actual method in class that implements TikTokEventListener
+     *
      * @return
      */
-    LiveClientBuilder addListener(TikTokEventListener listener);
+    LiveClientBuilder addListener(Object listener);
+
 
     /**
+     * Allows you to use own implementation of internal TikTokLive dependencies,
+     * when the default implementation does not meet your needs
+     *
+     * @param onCustomizeDependencies access to dependency container
+     * @return
+     */
+    LiveClientBuilder customize(Consumer<DependanceContainerBuilder> onCustomizeDependencies);
+
+    /**
+     * Builds new instance of the LiveClient
      *
      * @return LiveClient object
      */
     LiveClient build();
 
     /**
+     * Builds new instance of the LiveClient and connects to live
      *
-     * @return LiveClient object and connects to TikTok live
+     * @return LiveClient object
      */
     LiveClient buildAndConnect();
 
     /**
-     *
      * @return LiveClient object and connects to TikTok live asynchronously
      */
     CompletableFuture<LiveClient> buildAndConnectAsync();

API/src/main/java/io/github/jwdeveloper/tiktok/mappers/LiveMapper.java

@@ -27,18 +27,23 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.mappers.data.MappingAction;
 import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
 
+import java.util.List;
 import java.util.function.Function;
 
-public interface TikTokMapper {
+public interface LiveMapper {
 
     /**
-     * * if mapper is not found for messageName, TikTokLiveException is thrown
+     * when mapper is not found for messageName, TikTokLiveException is thrown
      *
      * @param messageName
      * @return TikTokMapperModel
      */
     TikTokMapperModel forMessage(String messageName);
 
+    /**
+     * @param mapperName protocol buffer class type
+     * @return
+     */
     TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName);
 
     TikTokMapperModel forMessage(String mapperName, MappingAction<MappingResult> onMapping);
@@ -49,10 +54,9 @@ public interface TikTokMapper {
 
     TikTokMapperModel forAnyMessage();
 
+    List<TikTokEvent> handleMapping(String messageName, byte[] bytes);
 
     boolean isRegistered(String mapperName);
 
     <T extends GeneratedMessageV3> boolean isRegistered(Class<T> mapperName);
-
-
 }

API/src/main/java/io/github/jwdeveloper/tiktok/mappers/LiveMapperHelper.java

@@ -26,7 +26,7 @@ import com.google.protobuf.GeneratedMessageV3;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokMessageMappingException;
 import io.github.jwdeveloper.tiktok.utils.ProtoBufferObject;
 
-public interface TikTokMapperHelper {
+public interface LiveMapperHelper {
 
     /**
      * @param bytes        protocol buffer data bytes

API/src/main/java/io/github/jwdeveloper/tiktok/mappers/data/MappingAction.java

@@ -22,7 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.mappers.data;
 
-import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
+import io.github.jwdeveloper.tiktok.mappers.LiveMapperHelper;
 
 @FunctionalInterface
 public interface MappingAction<T> {
@@ -33,6 +33,6 @@ public interface MappingAction<T> {
      * @param mapperHelper utils and helper methods that can be use to debbug/display/deserialize protocol buffer data
      * @return
      */
-    T onMapping(byte[] inputBytes, String messageName, TikTokMapperHelper mapperHelper);
+    T onMapping(byte[] inputBytes, String messageName, LiveMapperHelper mapperHelper);
 
 }

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

@@ -24,9 +24,8 @@ package io.github.jwdeveloper.tiktok.websocket;
 
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 
-public interface SocketClient {
+public interface LiveSocketClient {
     void start(LiveConnectionData.Response webcastResponse, LiveClient tikTokLiveClient);
     void stop();
 }

Client/pom.xml

@@ -5,13 +5,14 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.7.1-Release</version>
+        <version>1.8.2-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>Client</artifactId>
 
 
+
     <dependencies>
         <dependency>
             <groupId>com.google.code.gson</groupId>

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

@@ -23,19 +23,21 @@
 package io.github.jwdeveloper.tiktok;
 
 
+import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
 import io.github.jwdeveloper.tiktok.gifts.TikTokGiftsManager;
 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.concurrent.CompletableFuture;
+import java.util.function.Consumer;
 
 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) {
@@ -45,7 +47,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) {
@@ -55,7 +57,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) {
@@ -65,7 +67,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) {
@@ -75,20 +77,29 @@ 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) {
         return CompletableFuture.supplyAsync(() -> isHostNameValid(hostName));
     }
 
+    /**
+     * Use to get some data from TikTok about users are lives
+     *
+     * @return LiveHttpClient
+     */
+    public static LiveHttpClient requests(Consumer<LiveClientSettings> consumer) {
+        return new TikTokLiveHttpClient(consumer);
+    }
+
     /**
      * Use to get some data from TikTok about users are lives
      *
      * @return LiveHttpClient
      */
     public static LiveHttpClient requests() {
-        return new TikTokLiveHttpClient();
+        return requests(liveClientSettings -> {});
     }
 
     private static GiftsManager giftsManager;

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

@@ -26,7 +26,6 @@ import com.google.protobuf.ByteString;
 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.*;
 import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
@@ -36,37 +35,40 @@ 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 io.github.jwdeveloper.tiktok.websocket.LiveSocketClient;
+import lombok.Getter;
 
 import java.util.Base64;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
-public class TikTokLiveClient implements LiveClient {
-    private final TikTokRoomInfo liveRoomInfo;
+@Getter
+public class TikTokLiveClient implements LiveClient
+{
+    private final TikTokRoomInfo roomInfo;
     private final LiveHttpClient httpClient;
-    private final SocketClient webSocketClient;
-    private final TikTokLiveEventHandler tikTokEventHandler;
+    private final LiveSocketClient webSocketClient;
+    private final LiveEventsHandler 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;
+    private final GiftsManager giftManager;
+    private final LiveMessagesHandler messageHandler;
 
     public TikTokLiveClient(
-            TikTokLiveMessageHandler messageHandler,
+            LiveMessagesHandler messageHandler,
             GiftsManager giftsManager,
             TikTokRoomInfo tikTokLiveMeta,
             LiveHttpClient tiktokHttpClient,
-            SocketClient webSocketClient,
-            TikTokLiveEventHandler tikTokEventHandler,
+            LiveSocketClient webSocketClient,
+            LiveEventsHandler tikTokEventHandler,
             LiveClientSettings clientSettings,
-            TikTokListenersManager listenersManager,
+            ListenersManager listenersManager,
             Logger logger) {
         this.messageHandler = messageHandler;
-        this.giftsManager = giftsManager;
-        this.liveRoomInfo = tikTokLiveMeta;
+        this.giftManager = giftsManager;
+        this.roomInfo = tikTokLiveMeta;
         this.httpClient = tiktokHttpClient;
         this.webSocketClient = webSocketClient;
         this.tikTokEventHandler = tikTokEventHandler;
@@ -75,22 +77,6 @@ public class TikTokLiveClient implements LiveClient {
         this.logger = logger;
     }
 
-
-    public void connectAsync(Consumer<LiveClient> onConnection) {
-        CompletableFuture.runAsync(() -> {
-            connect();
-            onConnection.accept(this);
-        });
-    }
-
-
-    public CompletableFuture<LiveClient> connectAsync() {
-        return CompletableFuture.supplyAsync(() -> {
-            connect();
-            return this;
-        });
-    }
-
     public void connect() {
         try {
             tryConnect();
@@ -102,8 +88,7 @@ public class TikTokLiveClient implements LiveClient {
             if (e instanceof TikTokLiveOfflineHostException && clientSettings.isRetryOnConnectionFailure()) {
                 try {
                     Thread.sleep(clientSettings.getRetryConnectionTimeout().toMillis());
-                } catch (Exception ignored) {
-                }
+                } catch (Exception ignored) {}
                 logger.info("Reconnecting");
                 tikTokEventHandler.publish(this, new TikTokReconnectingEvent());
                 this.connect();
@@ -117,61 +102,59 @@ public class TikTokLiveClient implements LiveClient {
     }
 
     public void tryConnect() {
-        if (!liveRoomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
+        if (!roomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
             throw new TikTokLiveException("Already connected");
         }
 
         setState(ConnectionState.CONNECTING);
         tikTokEventHandler.publish(this, new TikTokConnectingEvent());
-        var userDataRequest = new LiveUserData.Request(liveRoomInfo.getHostName());
+        var userDataRequest = new LiveUserData.Request(roomInfo.getHostName());
         var userData = httpClient.fetchLiveUserData(userDataRequest);
-        liveRoomInfo.setStartTime(userData.getStartedAtTimeStamp());
-        liveRoomInfo.setRoomId(userData.getRoomId());
-
-        if (clientSettings.isFetchGifts())
-            giftsManager.attachGiftsList(httpClient.fetchRoomGiftsData(userData.getRoomId()).getGifts());
+        roomInfo.setStartTime(userData.getStartTime());
+        roomInfo.setRoomId(userData.getRoomId());
 
         if (userData.getUserStatus() == LiveUserData.UserStatus.Offline)
-            throw new TikTokLiveOfflineHostException("User is offline: " + liveRoomInfo.getHostName());
+            throw new TikTokLiveOfflineHostException("User is offline: " + roomInfo.getHostName());
 
         if (userData.getUserStatus() == LiveUserData.UserStatus.NotFound)
-            throw new TikTokLiveOfflineHostException("User not found: " + liveRoomInfo.getHostName());
+            throw new TikTokLiveUnknownHostException("User not found: " + roomInfo.getHostName());
 
         var liveDataRequest = new LiveData.Request(userData.getRoomId());
         var liveData = httpClient.fetchLiveData(liveDataRequest);
 
         if (liveData.isAgeRestricted() && clientSettings.isThrowOnAgeRestriction())
-            throw new TikTokLiveException("Livestream for " + liveRoomInfo.getHostName() + " is 18+ or age restricted!");
+            throw new TikTokLiveException("Livestream for " + roomInfo.getHostName() + " is 18+ or age restricted!");
 
         if (liveData.getLiveStatus() == LiveData.LiveStatus.HostNotFound)
-            throw new TikTokLiveOfflineHostException("LiveStream for " + liveRoomInfo.getHostName() + " could not be found.");
+            throw new TikTokLiveUnknownHostException("LiveStream for " + roomInfo.getHostName() + " could not be found.");
 
         if (liveData.getLiveStatus() == LiveData.LiveStatus.HostOffline)
-            throw new TikTokLiveOfflineHostException("LiveStream for " + liveRoomInfo.getHostName() + " not found, is the Host offline?");
+            throw new TikTokLiveOfflineHostException("LiveStream for " + roomInfo.getHostName() + " not found, is the Host offline?");
 
-        tikTokEventHandler.publish(this, new TikTokRoomDataResponseEvent(liveData));
-
-        liveRoomInfo.setTitle(liveData.getTitle());
-        liveRoomInfo.setViewersCount(liveData.getViewers());
-        liveRoomInfo.setTotalViewersCount(liveData.getTotalViewers());
-        liveRoomInfo.setAgeRestricted(liveData.isAgeRestricted());
-        liveRoomInfo.setHost(liveData.getHost());
+        roomInfo.setTitle(liveData.getTitle());
+        roomInfo.setViewersCount(liveData.getViewers());
+        roomInfo.setTotalViewersCount(liveData.getTotalViewers());
+        roomInfo.setAgeRestricted(liveData.isAgeRestricted());
+        roomInfo.setHost(liveData.getHost());
 
         var preconnectEvent = new TikTokPreConnectionEvent(userData, liveData);
         tikTokEventHandler.publish(this, preconnectEvent);
         if (preconnectEvent.isCancelConnection())
             throw new TikTokLiveException("TikTokPreConnectionEvent cancelled connection!");
 
+        if (clientSettings.isFetchGifts())
+            giftManager.attachGiftsList(httpClient.fetchRoomGiftsData(userData.getRoomId()).getGifts());
+
         var liveConnectionRequest = new LiveConnectionData.Request(userData.getRoomId());
         var liveConnectionData = httpClient.fetchLiveConnectionData(liveConnectionRequest);
         webSocketClient.start(liveConnectionData, this);
 
         setState(ConnectionState.CONNECTED);
-        tikTokEventHandler.publish(this, new TikTokRoomInfoEvent(liveRoomInfo));
+        tikTokEventHandler.publish(this, new TikTokRoomInfoEvent(roomInfo));
     }
 
     public void disconnect() {
-        if (liveRoomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
+        if (roomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
             return;
         }
         setState(ConnectionState.DISCONNECTED);
@@ -180,7 +163,7 @@ public class TikTokLiveClient implements LiveClient {
 
     private void setState(ConnectionState connectionState) {
         logger.info("TikTokLive client state: " + connectionState.name());
-        liveRoomInfo.setConnectionState(connectionState);
+        roomInfo.setConnectionState(connectionState);
     }
 
     public void publishEvent(TikTokEvent event) {
@@ -201,22 +184,15 @@ public class TikTokLiveClient implements LiveClient {
         messageHandler.handleSingleMessage(this, message);
     }
 
-    @Override
-    public GiftsManager getGiftManager() {
-        return giftsManager;
+
+    public void connectAsync(Consumer<LiveClient> onConnection) {
+        connectAsync().thenAccept(onConnection);
     }
 
-    public LiveRoomInfo getRoomInfo() {
-        return liveRoomInfo;
-    }
-
-    @Override
-    public ListenersManager getListenersManager() {
-        return listenersManager;
-    }
-
-    @Override
-    public Logger getLogger() {
-        return logger;
+    public CompletableFuture<LiveClient> connectAsync() {
+        return CompletableFuture.supplyAsync(() -> {
+            connect();
+            return this;
+        });
     }
 }

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

@@ -22,29 +22,25 @@
  */
 package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.dependance.Dependance;
+import io.github.jwdeveloper.dependance.api.DependanceContainer;
+import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
+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;
-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.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.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.*;
@@ -52,28 +48,31 @@ import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 import java.util.logging.Logger;
 
-import static io.github.jwdeveloper.tiktok.messages.enums.LinkMessageType.*;
-
 public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
     protected final LiveClientSettings clientSettings;
-    protected final TikTokLiveEventHandler eventHandler;
-    protected final List<TikTokEventListener> listeners;
-    protected Consumer<TikTokMapper> onCustomMappings;
-    protected Logger logger;
-    protected GiftsManager giftsManager;
+    protected final LiveEventsHandler eventHandler;
+    protected final List<Object> listeners;
+    protected final List<Consumer<LiveMapper>> onCustomMappings;
+    protected final List<Consumer<DependanceContainerBuilder>> onCustomDependencies;
 
     public TikTokLiveClientBuilder(String userName) {
         this.clientSettings = LiveClientSettings.createDefault();
         this.clientSettings.setHostName(userName);
         this.eventHandler = new TikTokLiveEventHandler();
         this.listeners = new ArrayList<>();
-        this.onCustomMappings = (e) -> {
-        };
+        this.onCustomMappings = new ArrayList<>();
+        this.onCustomDependencies = new ArrayList<>();
     }
 
-    public LiveClientBuilder onMapping(Consumer<TikTokMapper> onCustomMappings) {
-        this.onCustomMappings = onCustomMappings;
+    public LiveClientBuilder mappings(Consumer<LiveMapper> consumer) {
+        this.onCustomMappings.add(consumer);
+        return this;
+    }
+
+    @Override
+    public LiveClientBuilder onMappings(Consumer<LiveMapper> onCustomMappings) {
+        mappings(onCustomMappings);
         return this;
     }
 
@@ -82,12 +81,18 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return this;
     }
 
-    public TikTokLiveClientBuilder addListener(TikTokEventListener listener) {
+    public TikTokLiveClientBuilder addListener(Object listener) {
         if (listener != null)
             listeners.add(listener);
         return this;
     }
 
+    @Override
+    public LiveClientBuilder customize(Consumer<DependanceContainerBuilder> onCustomizeDependencies) {
+        this.onCustomDependencies.add(onCustomizeDependencies);
+        return this;
+    }
+
     protected void validate() {
         if (clientSettings.getClientLanguage() == null || clientSettings.getClientLanguage().isEmpty())
             clientSettings.setClientLanguage("en");
@@ -98,175 +103,92 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         if (clientSettings.getHostName().startsWith("@"))
             clientSettings.setHostName(clientSettings.getHostName().substring(1));
 
+        //TODO 250 Magic number
         if (clientSettings.getPingInterval() < 250)
-            throw new TikTokLiveException("Minimum allowed ping interval is 250 millseconds");
+            throw new TikTokLiveException("Minimum allowed ping interval is 250 milliseconds");
 
         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());
+        //Docs: https://github.com/jwdeveloper/DepenDance?tab=readme-ov-file#01-basic
+        var dependance = Dependance.newContainer();
 
-        var listenerManager = new TikTokListenersManager(listeners, eventHandler);
+        //config
+        dependance.registerSingleton(LiveClientSettings.class, clientSettings);
+        dependance.registerSingleton(Logger.class, LoggerFactory.create(clientSettings.getHostName(), clientSettings));
+        dependance.registerSingleton(TikTokRoomInfo.class, container ->
+        {
+            var roomInfo = new TikTokRoomInfo();
+            roomInfo.setHostName(clientSettings.getHostName());
+            return roomInfo;
+        });
 
-        var httpClientFactory = new HttpClientFactory(clientSettings);
+        //messages
+        dependance.registerSingleton(LiveEventsHandler.class, eventHandler);
+        dependance.registerSingleton(LiveMessagesHandler.class, TikTokLiveMessageHandler.class);
 
-        var liveHttpClient = clientSettings.isOffline() ?
-                new TikTokLiveHttpOfflineClient() :
-                new TikTokLiveHttpClient(httpClientFactory, clientSettings);
+        //listeners
+        dependance.registerSingleton(ListenersManager.class, TikTokListenersManager.class);
 
-        var eventsMapper = createMapper(giftsManager, tiktokRoomInfo);
-        var messageHandler = new TikTokLiveMessageHandler(eventHandler, eventsMapper);
+        //networking
+        dependance.registerSingleton(HttpClientFactory.class);
+        dependance.registerSingleton(TikTokWebSocketPingingTask.class);
+        if (clientSettings.isOffline()) {
+            dependance.registerSingleton(LiveSocketClient.class, TikTokWebSocketOfflineClient.class);
+            dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpOfflineClient.class);
+        } else {
+            dependance.registerSingleton(LiveSocketClient.class, TikTokWebSocketClient.class);
+            dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpClient.class);
+        }
 
-        var webSocketClient = clientSettings.isOffline() ?
-                new TikTokWebSocketOfflineClient(eventHandler) :
-                new TikTokWebSocketClient(
-                        clientSettings,
-                        messageHandler,
-                        eventHandler);
+        /* TODO in future, custom proxy implementation that can be provided via builder
+         * if(customProxy != null)
+         *    dependance.registerSingleton(TikTokProxyProvider.class,customProxy);
+         * else
+         *    dependance.registerSingleton(TikTokProxyProvider.class,DefaultProxyProvider.class);
+         */
 
-        return new TikTokLiveClient(
-                messageHandler,
-                giftsManager,
-                tiktokRoomInfo,
-                liveHttpClient,
-                webSocketClient,
-                eventHandler,
-                clientSettings,
-                listenerManager,
-                logger);
+        //gifts
+        if (clientSettings.isFetchGifts()) {
+            dependance.registerSingleton(GiftsManager.class, TikTokLive.gifts());
+        } else {
+            dependance.registerSingleton(GiftsManager.class, new TikTokGiftsManager(List.of()));
+        }
+
+        //mapper
+        dependance.registerSingleton(TikTokGenericEventMapper.class);
+        dependance.registerSingleton(LiveMapperHelper.class, TikTokLiveMapperHelper.class);
+        dependance.registerSingleton(LiveMapper.class, (container) ->
+        {
+            var dependace = (DependanceContainer) container.find(DependanceContainer.class);
+            var mapper = MessagesMapperFactory.create(dependace);
+            onCustomMappings.forEach(action -> action.accept(mapper));
+            return mapper;
+        });
+
+        //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);
+
+        onCustomDependencies.forEach(action -> action.accept(dependance));
+        var container = dependance.build();
+
+        var listenerManager = container.find(ListenersManager.class);
+        listeners.forEach(listenerManager::addListener);
+        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.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_REPLY -> new TikTokLinkReplyEvent(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);
-
-
-        onCustomMappings.accept(mapper);
-        return mapper;
-    }
-
-
     public LiveClient buildAndConnect() {
         var client = build();
         client.connect();
@@ -277,361 +199,9 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return build().connectAsync();
     }
 
-    public TikTokLiveClientBuilder onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
-        return this;
-    }
-
-    public LiveClientBuilder onChest(EventConsumer<TikTokChestEvent> event) {
-        eventHandler.subscribe(TikTokChestEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicFanTicket(EventConsumer<TikTokLinkMicFanTicketEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onEnvelope(EventConsumer<TikTokEnvelopeEvent> event) {
-        eventHandler.subscribe(TikTokEnvelopeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onShop(EventConsumer<TikTokShopEvent> event) {
-        eventHandler.subscribe(TikTokShopEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onDetect(EventConsumer<TikTokDetectEvent> event) {
-        eventHandler.subscribe(TikTokDetectEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkLayer(EventConsumer<TikTokLinkLayerEvent> event) {
-        eventHandler.subscribe(TikTokLinkLayerEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onConnected(EventConsumer<TikTokConnectedEvent> event) {
-        eventHandler.subscribe(TikTokConnectedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onPreConnection(EventConsumer<TikTokPreConnectionEvent> event) {
-        eventHandler.subscribe(TikTokPreConnectionEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onCaption(EventConsumer<TikTokCaptionEvent> event) {
-        eventHandler.subscribe(TikTokCaptionEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onQuestion(EventConsumer<TikTokQuestionEvent> event) {
-        eventHandler.subscribe(TikTokQuestionEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onRoomPin(EventConsumer<TikTokRoomPinEvent> event) {
-        eventHandler.subscribe(TikTokRoomPinEvent.class, event);
-        return this;
-    }
-
     @Override
-    public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> event) {
-        eventHandler.subscribe(eventClass, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
-        eventHandler.subscribe(TikTokRoomInfoEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
-        eventHandler.subscribe(TikTokLivePausedEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
-        eventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
-        eventHandler.subscribe(TikTokLikeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLink(EventConsumer<TikTokLinkEvent> 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) {
-        eventHandler.subscribe(TikTokBarrageEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onGift(EventConsumer<TikTokGiftEvent> event) {
-        eventHandler.subscribe(TikTokGiftEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onGiftCombo(EventConsumer<TikTokGiftComboEvent> event) {
-        eventHandler.subscribe(TikTokGiftComboEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicArmies(EventConsumer<TikTokLinkMicArmiesEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onEmote(EventConsumer<TikTokEmoteEvent> event) {
-        eventHandler.subscribe(TikTokEmoteEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onUnauthorizedMember(EventConsumer<TikTokUnauthorizedMemberEvent> event) {
-        eventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onInRoomBanner(EventConsumer<TikTokInRoomBannerEvent> event) {
-        eventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicMethod(EventConsumer<TikTokLinkMicMethodEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onSubscribe(EventConsumer<TikTokSubscribeEvent> event) {
-        eventHandler.subscribe(TikTokSubscribeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onPoll(EventConsumer<TikTokPollEvent> event) {
-        eventHandler.subscribe(TikTokPollEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onFollow(EventConsumer<TikTokFollowEvent> event) {
-        eventHandler.subscribe(TikTokFollowEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
-        eventHandler.subscribe(TikTokCommentEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public LiveClientBuilder onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
-        eventHandler.subscribe(TikTokHttpResponseEvent.class, action);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onGoalUpdate(EventConsumer<TikTokGoalUpdateEvent> event) {
-        eventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onRankUpdate(EventConsumer<TikTokRankUpdateEvent> event) {
-        eventHandler.subscribe(TikTokRankUpdateEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onIMDelete(EventConsumer<TikTokIMDeleteEvent> event) {
-        eventHandler.subscribe(TikTokIMDeleteEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event) {
-        eventHandler.subscribe(TikTokLiveEndedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onError(EventConsumer<TikTokErrorEvent> event) {
-        eventHandler.subscribe(TikTokErrorEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onJoin(EventConsumer<TikTokJoinEvent> event) {
-        eventHandler.subscribe(TikTokJoinEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onRankText(EventConsumer<TikTokRankTextEvent> event) {
-        eventHandler.subscribe(TikTokRankTextEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onShare(EventConsumer<TikTokShareEvent> event) {
-        eventHandler.subscribe(TikTokShareEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onUnhandledMember(EventConsumer<TikTokUnhandledMemberEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onSubNotify(EventConsumer<TikTokSubNotifyEvent> event) {
-        eventHandler.subscribe(TikTokSubNotifyEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicBattle(EventConsumer<TikTokLinkMicBattleEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onDisconnected(EventConsumer<TikTokDisconnectedEvent> event) {
-        eventHandler.subscribe(TikTokDisconnectedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onUnhandledControl(EventConsumer<TikTokUnhandledControlEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onEvent(EventConsumer<TikTokEvent> event) {
-        eventHandler.subscribe(TikTokEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onReconnecting(EventConsumer<TikTokReconnectingEvent> event) {
-        eventHandler.subscribe(TikTokReconnectingEvent.class, event);
+    public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> action) {
+        eventHandler.subscribe(eventClass, action);
         return this;
     }
 }

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

@@ -23,15 +23,13 @@
 package io.github.jwdeveloper.tiktok;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
 import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
-public class TikTokLiveEventHandler {
+public class TikTokLiveEventHandler implements LiveEventsHandler {
     private final Map<Class<?>, Set<EventConsumer>> events;
 
     public TikTokLiveEventHandler() {
@@ -39,21 +37,8 @@ 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);
-            }
-        }
-
-
-        if (!events.containsKey(tikTokEvent.getClass())) {
-            return;
-        }
-        var handlers = events.get(tikTokEvent.getClass());
-        for (var handler : handlers) {
-            handler.onEvent(tikTokLiveClient, tikTokEvent);
-        }
+        Optional.ofNullable(events.get(TikTokEvent.class)).ifPresent(handlers -> handlers.forEach(handler -> handler.onEvent(tikTokLiveClient, tikTokEvent)));
+        Optional.ofNullable(events.get(tikTokEvent.getClass())).ifPresent(handlers -> handlers.forEach(handler -> handler.onEvent(tikTokLiveClient, tikTokEvent)));
     }
 
     public <T extends TikTokEvent> void subscribe(Class<?> clazz, EventConsumer<T> event) {
@@ -65,22 +50,10 @@ public class TikTokLiveEventHandler {
     }
 
     public <T extends TikTokEvent> void unsubscribe(EventConsumer<T> consumer) {
-        for (var entry : events.entrySet()) {
-            entry.getValue().remove(consumer);
-        }
+		events.forEach((key, value) -> value.remove(consumer));
     }
 
     public <T extends TikTokEvent> void unsubscribe(Class<?> clazz, EventConsumer<T> consumer) {
-        if (clazz == null) {
-            return;
-        }
-
-        if (!events.containsKey(clazz)) {
-            return;
-        }
-
-        var eventSet = events.get(clazz);
-        eventSet.remove(consumer);
-
-    }
-}
+        Optional.ofNullable(clazz).map(events::get).ifPresent(consumers -> consumers.remove(consumer));
+	}
+}

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

@@ -23,6 +23,7 @@
 package io.github.jwdeveloper.tiktok;
 
 import com.google.protobuf.InvalidProtocolBufferException;
+import io.github.jwdeveloper.dependance.injector.api.annotations.Inject;
 import io.github.jwdeveloper.tiktok.common.*;
 import io.github.jwdeveloper.tiktok.data.requests.*;
 import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
@@ -32,6 +33,7 @@ import io.github.jwdeveloper.tiktok.http.mappers.*;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 
 import java.net.http.HttpResponse;
+import java.util.function.Consumer;
 import java.util.logging.Logger;
 
 public class TikTokLiveHttpClient implements LiveHttpClient
@@ -53,17 +55,19 @@ public class TikTokLiveHttpClient implements LiveHttpClient
     private final GiftsDataMapper giftsDataMapper;
     private final Logger logger;
 
-    public TikTokLiveHttpClient(HttpClientFactory factory, LiveClientSettings settings) {
+    @Inject
+    public TikTokLiveHttpClient(HttpClientFactory factory) {
         this.httpFactory = factory;
-        this.clientSettings = settings;
+        this.clientSettings = factory.getLiveClientSettings();
         this.logger = LoggerFactory.create("HttpClient-"+hashCode(), clientSettings);
         liveUserDataMapper = new LiveUserDataMapper();
         liveDataMapper = new LiveDataMapper();
         giftsDataMapper = new GiftsDataMapper();
     }
 
-    public TikTokLiveHttpClient() {
-        this(new HttpClientFactory(LiveClientSettings.createDefault()), LiveClientSettings.createDefault());
+    public TikTokLiveHttpClient(Consumer<LiveClientSettings> consumer) {
+        this(new HttpClientFactory(LiveClientSettings.createDefault()));
+        consumer.accept(clientSettings);
     }
 
     public GiftsData.Response fetchRoomGiftsData(String room_id) {
@@ -132,7 +136,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         var url = TIKTOK_URL_WEB + "api-live/user/room";
         var result = httpFactory.client(url)
             .withParam("uniqueId", request.getUserName())
-            .withParam("sourceType", "54")
+            .withParam("sourceType", "54") //MAGIC NUMBER, WHAT 54 means?
             .build()
             .toJsonResponse();
 
@@ -191,7 +195,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
                     .withParam("internal_ext", webcastResponse.getInternalExt())
                     .withParams(webcastResponse.getRouteParamsMapMap())
                     .build()
-                    .toUrl();
+                    .toUri();
 
             return new LiveConnectionData.Response(websocketCookie, webSocketUrl, webcastResponse);
         } catch (InvalidProtocolBufferException e) {
@@ -199,7 +203,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         }
     }
 
-    private ActionResult<HttpResponse<byte[]>> getStartingPayload(LiveConnectionData.Request request) {
+    protected ActionResult<HttpResponse<byte[]>> getStartingPayload(LiveConnectionData.Request request) {
         var proxyClientSettings = clientSettings.getHttpSettings().getProxyClientSettings();
         if (proxyClientSettings.isEnabled()) {
             while (proxyClientSettings.hasNext()) {
@@ -211,10 +215,10 @@ public class TikTokLiveHttpClient implements LiveHttpClient
         return getByteResponse(request.getRoomId());
     }
 
-    private ActionResult<HttpResponse<byte[]>> getByteResponse(String room_id) {
+    protected ActionResult<HttpResponse<byte[]>> getByteResponse(String room_id) {
         HttpClientBuilder builder = httpFactory.client(TIKTOK_SIGN_API)
             .withParam("client", "ttlive-java")
-            .withParam("uuc", "1")
+            .withParam("uuc", "1") //MAGIC NUMBER!
             .withParam("room_id", room_id);
 
         if (clientSettings.getApiKey() != null)

Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveHttpOfflineClient.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;
 
 import io.github.jwdeveloper.tiktok.data.models.Picture;

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

@@ -30,18 +30,20 @@ import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketRespons
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandledMessageEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageException;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.mappers.TikTokLiveMapper;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
+import io.github.jwdeveloper.tiktok.live.LiveMessagesHandler;
+import io.github.jwdeveloper.tiktok.mappers.LiveMapper;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 import io.github.jwdeveloper.tiktok.utils.Stopwatch;
 
 import java.time.Duration;
 
-public class TikTokLiveMessageHandler {
+public class TikTokLiveMessageHandler implements LiveMessagesHandler {
 
-    private final TikTokLiveEventHandler tikTokEventHandler;
-    private final TikTokLiveMapper mapper;
+    private final LiveEventsHandler tikTokEventHandler;
+    private final LiveMapper mapper;
 
-    public TikTokLiveMessageHandler(TikTokLiveEventHandler tikTokEventHandler, TikTokLiveMapper mapper) {
+    public TikTokLiveMessageHandler(LiveEventsHandler tikTokEventHandler, LiveMapper mapper) {
         this.tikTokEventHandler = tikTokEventHandler;
         this.mapper = mapper;
     }
@@ -58,13 +60,13 @@ public class TikTokLiveMessageHandler {
         }
     }
 
-    public void handleSingleMessage(LiveClient client, WebcastResponse.Message message)
-    {
+    public void handleSingleMessage(LiveClient client, WebcastResponse.Message message) {
         var messageClassName = message.getMethod();
         if (!mapper.isRegistered(messageClassName)) {
             tikTokEventHandler.publish(client, new TikTokWebsocketUnhandledMessageEvent(message));
             return;
         }
+
         var stopwatch = new Stopwatch();
         stopwatch.start();
         var events = mapper.handleMapping(messageClassName, message.getPayload().toByteArray());
@@ -76,5 +78,4 @@ public class TikTokLiveMessageHandler {
             tikTokEventHandler.publish(client, event);
         }
     }
-
-}
+}

Client/src/main/java/io/github/jwdeveloper/tiktok/common/ActionResult.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 com.google.gson.*;

Client/src/main/java/io/github/jwdeveloper/tiktok/common/ActionResultBuilder.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 lombok.Setter;

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,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.gifts;
 
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
@@ -7,6 +29,7 @@ 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;
 

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

@@ -90,14 +90,14 @@ public class HttpClient {
         return toResponse().map(HttpResponse::body);
     }
 
-    public URI toUrl() {
+    public URI toUri() {
         var stringUrl = prepareUrlWithParameters(url, httpClientSettings.getParams());
         return URI.create(stringUrl);
     }
 
     protected HttpRequest prepareGetRequest() {
         var requestBuilder = HttpRequest.newBuilder().GET();
-        requestBuilder.uri(toUrl());
+        requestBuilder.uri(toUri());
         requestBuilder.timeout(httpClientSettings.getTimeout());
         httpClientSettings.getHeaders().forEach(requestBuilder::setHeader);
 

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

@@ -23,7 +23,9 @@
 package io.github.jwdeveloper.tiktok.http;
 
 import io.github.jwdeveloper.tiktok.data.settings.*;
+import lombok.Getter;
 
+@Getter
 public class HttpClientFactory {
     private final LiveClientSettings liveClientSettings;
 
@@ -34,11 +36,4 @@ public class HttpClientFactory {
     public HttpClientBuilder client(String url) {
         return new HttpClientBuilder(url, liveClientSettings.getHttpSettings().clone());
     }
-
-    //Does not contains default httpClientSettings, Params, headers, etd
-    public HttpClientBuilder clientEmpty(String url) {
-        var settings = new HttpClientSettings();
-        settings.setProxyClientSettings(liveClientSettings.getHttpSettings().getProxyClientSettings());
-        return new HttpClientBuilder(url, settings);
-    }
 }

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

@@ -95,7 +95,7 @@ public class HttpProxyClient extends HttpClient {
 				public X509Certificate[] getAcceptedIssuers() { return null; }
 			}}, null);
 
-			URL url = toUrl().toURL();
+			URL url = toUri().toURL();
 
 			if (proxySettings.hasNext()) {
 				try {
@@ -117,7 +117,7 @@ public class HttpProxyClient extends HttpClient {
 
 					var responseInfo = createResponseInfo(socksConnection.getResponseCode(), headers);
 
-					var response = createHttpResponse(body, toUrl(), responseInfo);
+					var response = createHttpResponse(body, toUri(), responseInfo);
 
 					return ActionResult.success(response);
 				} catch (IOException e) {

Client/src/main/java/io/github/jwdeveloper/tiktok/http/mappers/HttpRequestJsonMapper.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.http.mappers;
 
 import com.google.gson.*;

Client/src/main/java/io/github/jwdeveloper/tiktok/http/mappers/HttpResponseJsonMapper.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.http.mappers;
 
 import com.google.gson.*;

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

@@ -22,19 +22,26 @@
  */
 package io.github.jwdeveloper.tiktok.listener;
 
+import io.github.jwdeveloper.tiktok.annotations.Priority;
+
 import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
+import lombok.Data;
 
-import lombok.Value;
-
-import java.util.List;
-import java.util.Map;
+import java.lang.reflect.Method;
 
 
-@Value
-public class ListenerBindingModel
-{
+@Data
+public class ListenerMethodInfo {
+    private Object listener;
 
-    TikTokEventListener listener;
+    private Class eventType;
 
-    Map<Class<?>, List<EventConsumer<?>>> events;
+    private Method method;
+
+    private Priority priority;
+
+    private boolean async;
+
+    private EventConsumer action = (a, b) -> {
+    };
 }

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

@@ -23,103 +23,135 @@
 package io.github.jwdeveloper.tiktok.listener;
 
 
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
+import io.github.jwdeveloper.dependance.api.DependanceContainer;
 import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
+import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokEventListenerMethodException;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
-import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
 import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicReference;
 
 public class TikTokListenersManager implements ListenersManager {
-    private final TikTokLiveEventHandler eventObserver;
-    private final List<ListenerBindingModel> bindingModels;
 
-    public TikTokListenersManager(List<TikTokEventListener> listeners, TikTokLiveEventHandler tikTokEventHandler) {
-        this.eventObserver = tikTokEventHandler;
-        this.bindingModels = new ArrayList<>(listeners.size());
-        for (var listener : listeners) {
-            addListener(listener);
-        }
+    private final Map<Object, List<ListenerMethodInfo>> listeners;
+    private final LiveEventsHandler eventsHandler;
+    private final ExecutorService executorService;
+    private final DependanceContainer dependanceContainer;
+
+
+    public TikTokListenersManager(LiveEventsHandler tikTokEventHandler,
+                                  DependanceContainer dependanceContainer) {
+        this.eventsHandler = tikTokEventHandler;
+        this.dependanceContainer = dependanceContainer;
+        this.listeners = new HashMap<>();
+        executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
     }
 
     @Override
-    public List<TikTokEventListener> getListeners() {
-        return bindingModels.stream().map(ListenerBindingModel::getListener).toList();
+    public List<Object> getListeners() {
+        return listeners.keySet().stream().toList();
     }
 
     @Override
-    public void addListener(TikTokEventListener listener) {
-        var alreadyExists = bindingModels.stream().filter(e -> e.getListener() == listener).findAny();
-        if (alreadyExists.isPresent()) {
+    public void addListener(Object listener) {
+        if (listeners.containsKey(listener)) {
             throw new TikTokLiveException("Listener " + listener.getClass() + " has already been registered");
         }
-        var bindingModel = bindToEvents(listener);
 
-        for (var eventEntrySet : bindingModel.getEvents().entrySet()) {
-            var eventType = eventEntrySet.getKey();
-            for (var methods : eventEntrySet.getValue()) {
-                eventObserver.subscribe(eventType, methods);
-            }
+        var methodsInfo = getMethodsInfo(listener);
+        for (var methodInfo : methodsInfo) {
+            eventsHandler.subscribe(methodInfo.getEventType(), methodInfo.getAction());
         }
-        bindingModels.add(bindingModel);
+        listeners.put(listener, methodsInfo);
     }
 
     @Override
-    public void removeListener(TikTokEventListener listener) {
-        var optional = bindingModels.stream().filter(e -> e.getListener() == listener).findAny();
-        if (optional.isEmpty()) {
+    public void removeListener(Object listener) {
+        if (!listeners.containsKey(listener)) {
             return;
         }
-
-        var bindingModel = optional.get();
-
-        for (var eventEntrySet : bindingModel.getEvents().entrySet()) {
-            var eventType = eventEntrySet.getKey();
-            for (var methods : eventEntrySet.getValue()) {
-                eventObserver.unsubscribe(eventType, methods);
-            }
+        var methodsInfo = listeners.get(listener);
+        for (var methodInfo : methodsInfo) {
+            eventsHandler.unsubscribe(methodInfo.getEventType(), methodInfo.getAction());
         }
-        bindingModels.remove(optional.get());
+        listeners.remove(listener);
     }
 
-    private ListenerBindingModel bindToEvents(TikTokEventListener listener) {
+    private List<ListenerMethodInfo> getMethodsInfo(Object listener) {
+        return Arrays.stream(listener.getClass().getDeclaredMethods())
+                .filter(e -> e.isAnnotationPresent(TikTokEventObserver.class))
+                .filter(e -> e.getParameterCount() >= 1)
+                .map(method -> getSingleMethodInfo(listener, method))
+                .sorted(Comparator.comparingInt(a -> a.getPriority().value))
+                .toList();
+    }
 
-        var clazz = listener.getClass();
-        var methods = Arrays.stream(clazz.getDeclaredMethods()).filter(m ->
-                m.getParameterCount() == 2 &&
-                        m.isAnnotationPresent(TikTokEventObserver.class)).toList();
-        var eventsMap = new HashMap<Class<?>, List<EventConsumer<?>>>();
-        for (var method : methods) {
-            var liveclientClass = method.getParameterTypes()[0];
-            var eventClass = method.getParameterTypes()[1];
+    private ListenerMethodInfo getSingleMethodInfo(Object listener, Method method) {
 
-            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());
-            }
+        method.setAccessible(true);
+        var annotation = method.getAnnotation(TikTokEventObserver.class);
+        var tiktokEventType = Arrays.stream(method.getParameterTypes())
+                .filter(TikTokEvent.class::isAssignableFrom)
+                .findFirst()
+                .orElseThrow(() -> new TikTokEventListenerMethodException("Method " + method.getName() + "() must have only one parameter that inherits from class " + 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());
-            }
+        var info = new ListenerMethodInfo();
+        info.setListener(listener);
+        info.setAsync(annotation.async());
+        info.setPriority(annotation.priority());
+        info.setEventType(tiktokEventType);
+        info.setAction(createAction(listener, method, tiktokEventType));
 
-            EventConsumer eventMethodRef = (liveClient, event) ->
+        if (info.isAsync()) {
+            var action = info.getAction();
+            info.setAction((liveClient, event) ->
             {
-                try {
-                    method.setAccessible(true);
-                    method.invoke(listener, liveClient, event);
-                } catch (Exception e) {
-                    throw new TikTokEventListenerMethodException(e);
-                }
-            };
-            eventsMap.computeIfAbsent(eventClass, (a) -> new ArrayList<>()).add(eventMethodRef);
+                executorService.submit(() ->
+                {
+                    action.onEvent(liveClient, event);
+                });
+            });
         }
-        return new ListenerBindingModel(listener, eventsMap);
+        return info;
+    }
+
+
+    //I know, implementation of this might look complicated
+    private EventConsumer createAction(Object listener, Method method, Class tiktokEventType) {
+        AtomicReference<Object> eventObjectRef = new AtomicReference<>();
+        var methodContainer = dependanceContainer.createChildContainer()
+                .configure(configuration ->
+                {
+                    //Modifying container, so it returns TikTokEvent object instance,
+                    //when TikTokEvent type is encountered in the methods parameters
+                    configuration.onInjection(injectionEvent ->
+                    {
+                        if (injectionEvent.input().isAssignableFrom(tiktokEventType)) {
+                            return eventObjectRef.get();
+                        }
+                        return injectionEvent.output();
+                    });
+                })
+                .build();
+
+        return (liveClient, event) ->
+        {
+            try {
+                eventObjectRef.set(event);
+                //Creating list of input objects based on method parameters
+                //Objects are received from container
+                var parameters = methodContainer.resolveParameters(method);
+                method.invoke(listener, parameters);
+            } catch (Exception e) {
+                eventsHandler.publish(liveClient, new TikTokErrorEvent(new TikTokEventListenerMethodException(e)));
+            }
+        };
     }
 }

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

@@ -0,0 +1,152 @@
+/*
+ * 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.tiktok.data.events.*;
+import io.github.jwdeveloper.tiktok.data.events.link.*;
+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 helper = container.find(LiveMapperHelper.class);
+        var mapper = new TikTokLiveMapper(helper);
+
+        //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/TikTokGenericEventMapper.java

@@ -27,26 +27,24 @@ import io.github.jwdeveloper.tiktok.exceptions.TikTokMessageMappingException;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 
 /**
  *  Goal of this class is to map ProtocolBuffer objects to TikTok Event in generic way
- *
- *  First parameter is ProtocolBuffer class type
- *  Second parameters is TikTokEvent class type
- *  Third parameters is bytes payload
- *
- *    mapToEvent(WebcastGiftMessage.class, TikTokGiftEvent.class, payload)
- *
- *    How does it work?
- *    1. Finds method `parseFrom(byte[] bytes)` inside ProtocolBuffer class
- *    2. put payload to the method methods and create new instance of ProtcolBuffer object
- *    3. Finds in TikTokEvent constructor that takes ProtocolBuffer type as parameter
- *    4. create new Instance in TikTokEvents using object from step 2 and constructor from step 3
- *
- *    methodCache and constructorCache are used to boost performance
+ *  <ul>
+ *      <li>First parameter is ProtocolBuffer class type</li>
+ *      <li>Second parameters is TikTokEvent class type</li>
+ *      <li>Third parameters is bytes payload</li>
+ *  </ul>
+ *  <p>mapToEvent(WebcastGiftMessage.class, TikTokGiftEvent.class, payload)</p>
+ *  <p>How does it work?</p>
+ *  <ol>
+ *      <li>Finds method `parseFrom(byte[] bytes)` inside ProtocolBuffer class</li>
+ *      <li>Put payload to the method methods and create new instance of ProtcolBuffer object</li>
+ *      <li>Finds in TikTokEvent constructor that takes ProtocolBuffer type as parameter</li>
+ *      <li>Create new Instance in TikTokEvents using object from step 2 and constructor from step 3</li>
+ *  </ol>
+ *   methodCache and constructorCache are used to boost performance
  */
 public class TikTokGenericEventMapper {
 
@@ -55,7 +53,7 @@ public class TikTokGenericEventMapper {
 
     private final Map<Class<?>, Method> methodCache;
     private final Map<TypePair, Constructor<?>> constructorCache;
-
+    private static final String PARSE_FIELD = "parseFrom";
     public TikTokGenericEventMapper() {
         this.methodCache = new HashMap<>();
         this.constructorCache = new HashMap<>();
@@ -74,34 +72,27 @@ public class TikTokGenericEventMapper {
         }
     }
 
-    public Method getParsingMethod(Class<?> input) throws NoSuchMethodException {
-        if (methodCache.containsKey(input)) {
-            return methodCache.get(input);
-        }
-        var method = input.getDeclaredMethod("parseFrom", byte[].class);
-        methodCache.put(input, method);
-        return method;
+    public Method getParsingMethod(Class<?> input) throws RuntimeException {
+        return methodCache.computeIfAbsent(input, aClass -> {
+			try {
+				return aClass.getDeclaredMethod(PARSE_FIELD, byte[].class);
+			} catch (NoSuchMethodException e) {
+				throw new RuntimeException(e);
+			}
+		});
     }
 
     private Constructor<?> getParsingConstructor(Class<?> input, Class<?> output) {
-        var pair = new TypePair(input, output);
-        if (constructorCache.containsKey(pair)) {
-            return constructorCache.get(pair);
-        }
-
-        var optional = Arrays.stream(output.getConstructors())
+        return constructorCache.computeIfAbsent(new TypePair(input, output), pair -> {
+            var optional = Arrays.stream(output.getConstructors())
                 .filter(ea -> Arrays.stream(ea.getParameterTypes())
-                        .toList()
-                        .contains(input))
+                    .toList()
+                    .contains(input))
                 .findFirst();
 
-        if (optional.isEmpty()) {
-            throw new TikTokMessageMappingException(input, output, "Unable to find constructor with input class type");
-        }
-
-        constructorCache.put(pair, optional.get());
-        return optional.get();
+            if (optional.isEmpty())
+				throw new TikTokMessageMappingException(input, output, "Unable to find constructor with input class type");
+            return optional.get();
+        });
     }
-
-
-}
+}

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

@@ -23,35 +23,28 @@
 package io.github.jwdeveloper.tiktok.mappers;
 
 import com.google.protobuf.GeneratedMessageV3;
-import io.github.jwdeveloper.tiktok.TikTokLive;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.mappers.data.MappingAction;
-import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+import io.github.jwdeveloper.tiktok.mappers.data.*;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Function;
 
-public class TikTokLiveMapper implements TikTokMapper {
+public class TikTokLiveMapper implements LiveMapper {
 
     private final Map<String, TikTokLiveMapperModel> mappers;
-    private final TikTokMapperHelper mapperUtils;
+    private final LiveMapperHelper mapperUtils;
     private final TikTokLiveMapperModel globalMapperModel;
+    private static final String GLOBAL_MESSAGE = "GLOBAL MESSAGE";
 
-    public TikTokLiveMapper(TikTokMapperHelper mapperUtils) {
+    public TikTokLiveMapper(LiveMapperHelper mapperUtils) {
         this.mappers = new HashMap<>();
         this.mapperUtils = mapperUtils;
-        this.globalMapperModel = new TikTokLiveMapperModel("any message");
+        this.globalMapperModel = new TikTokLiveMapperModel(GLOBAL_MESSAGE);
     }
 
     @Override
     public TikTokMapperModel forMessage(String messageName) {
-        if (!isRegistered(messageName)) {
-            var model = new TikTokLiveMapperModel(messageName);
-            mappers.put(messageName, model);
-        }
-        return mappers.get(messageName);
+        return mappers.computeIfAbsent(messageName, TikTokLiveMapperModel::new);
     }
 
     @Override
@@ -66,7 +59,6 @@ public class TikTokLiveMapper implements TikTokMapper {
         return model;
     }
 
-
     @Override
     public TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName, MappingAction<MappingResult> onMapping) {
         var model = forMessage(mapperName);
@@ -84,7 +76,6 @@ public class TikTokLiveMapper implements TikTokMapper {
         return globalMapperModel;
     }
 
-
     public boolean isRegistered(String mapperName) {
         return mappers.containsKey(mapperName);
     }
@@ -94,23 +85,19 @@ public class TikTokLiveMapper implements TikTokMapper {
     }
 
     public List<TikTokEvent> handleMapping(String messageName, byte[] bytes) {
-        if (!isRegistered(messageName)) {
-            return List.of();
-        }
         var mapperModel = mappers.get(messageName);
+        if (mapperModel == null)
+            return List.of();
 
         var inputBytes = mapperModel.getOnBeforeMapping().onMapping(bytes, messageName, mapperUtils);
         var globalInputBytes = globalMapperModel.getOnBeforeMapping().onMapping(inputBytes, messageName, mapperUtils);
 
-
         var mappingResult = mapperModel.getOnMapping().onMapping(globalInputBytes, messageName, mapperUtils);
 
-        if (mappingResult == null) {
-            mappingResult = globalMapperModel.getOnMapping().onMapping(globalInputBytes, messageName, mapperUtils);
-        }
+        if (mappingResult == null)
+			mappingResult = globalMapperModel.getOnMapping().onMapping(globalInputBytes, messageName, mapperUtils);
 
         var afterMappingResult = mapperModel.getOnAfterMapping().apply(mappingResult);
-        var globalAfterMappingResult = globalMapperModel.getOnAfterMapping().apply(MappingResult.of(mappingResult.getSource(), afterMappingResult));
-        return globalAfterMappingResult;
+		return globalMapperModel.getOnAfterMapping().apply(MappingResult.of(mappingResult.getSource(), afterMappingResult));
     }
-}
+}

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

@@ -28,7 +28,10 @@ import io.github.jwdeveloper.tiktok.utils.JsonUtil;
 import io.github.jwdeveloper.tiktok.utils.ProtoBufferObject;
 import io.github.jwdeveloper.tiktok.utils.ProtocolUtils;
 
-public class TikTokLiveMapperHelper implements TikTokMapperHelper {
+public class TikTokLiveMapperHelper implements LiveMapperHelper {
+
+    private static final String PACKAGE_PREFIX = "io.github.jwdeveloper.tiktok.messages.webcast.";
+
     private final TikTokGenericEventMapper genericMapper;
 
     public TikTokLiveMapperHelper(TikTokGenericEventMapper genericMapper) {
@@ -39,6 +42,7 @@ public class TikTokLiveMapperHelper implements TikTokMapperHelper {
     public <T extends GeneratedMessageV3> T bytesToWebcastObject(byte[] bytes, Class<T> messageClass) {
         try {
             var parsingMethod = genericMapper.getParsingMethod(messageClass);
+            //NULL is passed, since Parsing method is Static
             var sourceObject = parsingMethod.invoke(null, bytes);
             return (T) sourceObject;
         } catch (Exception e) {
@@ -49,7 +53,7 @@ public class TikTokLiveMapperHelper implements TikTokMapperHelper {
     @Override
     public Object bytesToWebcastObject(byte[] bytes, String messageName) {
         try {
-            var packageName = "io.github.jwdeveloper.tiktok.messages.webcast." + messageName;
+            var packageName = PACKAGE_PREFIX + messageName;
             var clazz = Class.forName(packageName);
             return bytesToWebcastObject(bytes, (Class<? extends GeneratedMessageV3>) clazz);
         } catch (Exception e) {
@@ -60,7 +64,7 @@ public class TikTokLiveMapperHelper implements TikTokMapperHelper {
     @Override
     public boolean isMessageHasProtoClass(String messageName) {
         try {
-            var packageName = "io.github.jwdeveloper.tiktok.messages.webcast." + messageName;
+            var packageName = PACKAGE_PREFIX + messageName;
             Class.forName(packageName);
             return true;
         } catch (Exception e) {

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/TikTokGiftEventHandler.java

@@ -28,7 +28,7 @@ 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.live.GiftsManager;
-import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
+import io.github.jwdeveloper.tiktok.mappers.LiveMapperHelper;
 import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import lombok.SneakyThrows;
@@ -38,7 +38,6 @@ import java.util.*;
 public class TikTokGiftEventHandler {
     private final Map<Long, WebcastGiftMessage> giftsMessages;
     private final TikTokRoomInfo tikTokRoomInfo;
-
     private final GiftsManager giftsManager;
 
     public TikTokGiftEventHandler(GiftsManager giftsManager, TikTokRoomInfo tikTokRoomInfo) {
@@ -48,18 +47,13 @@ public class TikTokGiftEventHandler {
     }
 
     @SneakyThrows
-    public MappingResult handleGifts(byte[] msg, String name, TikTokMapperHelper helper) {
+    public MappingResult handleGifts(byte[] msg, String name, LiveMapperHelper helper) {
         var currentMessage = WebcastGiftMessage.parseFrom(msg);
         var gifts = handleGift(currentMessage);
         return MappingResult.of(currentMessage, gifts);
     }
 
     public List<TikTokEvent> handleGift(WebcastGiftMessage currentMessage) {
-        var userId = currentMessage.getUser().getId();
-        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, GiftComboStateType.Finished);
@@ -67,7 +61,11 @@ public class TikTokGiftEventHandler {
             return List.of(comboEvent, giftEvent);
         }
 
-        if (!containsPreviousMessage) {
+        var userId = currentMessage.getUser().getId();
+        var currentType = GiftComboStateType.fromNumber(currentMessage.getSendType());
+        var previousMessage = giftsMessages.get(userId);
+
+        if (previousMessage == null) {
             if (currentType == GiftComboStateType.Finished) {
                 return List.of(getGiftEvent(currentMessage));
             } else {
@@ -76,7 +74,6 @@ public class TikTokGiftEventHandler {
             }
         }
 
-        var previousMessage = giftsMessages.get(userId);
         var previousType = GiftComboStateType.fromNumber(previousMessage.getSendType());
         if (currentType == GiftComboStateType.Active &&
                 previousType == GiftComboStateType.Active) {
@@ -114,9 +111,9 @@ public class TikTokGiftEventHandler {
             gift = giftsManager.getByName(giftMessage.getGift().getName());
         if (gift == Gift.UNDEFINED) {
             gift = new Gift(giftId,
-                    giftMessage.getGift().getName(),
-                    giftMessage.getGift().getDiamondCount(),
-                    Picture.map(giftMessage.getGift().getImage()));
+                giftMessage.getGift().getName(),
+                giftMessage.getGift().getDiamondCount(),
+                Picture.map(giftMessage.getGift().getImage()));
 
             giftsManager.attachGift(gift);
         }

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

@@ -31,7 +31,7 @@ import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
 import io.github.jwdeveloper.tiktok.data.models.RankingUser;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
-import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
+import io.github.jwdeveloper.tiktok.mappers.LiveMapperHelper;
 import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLikeMessage;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLiveIntroMessage;
@@ -86,7 +86,7 @@ public class TikTokRoomInfoEventHandler {
     }
 
     @SneakyThrows
-    public MappingResult handleMemberMessage(byte[] msg, String name, TikTokMapperHelper helper) {
+    public MappingResult handleMemberMessage(byte[] msg, String name, LiveMapperHelper helper) {
         var message = WebcastMemberMessage.parseFrom(msg);
 
         var event = switch (message.getAction()) {
@@ -103,7 +103,7 @@ public class TikTokRoomInfoEventHandler {
     }
 
     @SneakyThrows
-    public MappingResult handleLike(byte[] msg, String name, TikTokMapperHelper helper) {
+    public MappingResult handleLike(byte[] msg, String name, LiveMapperHelper helper) {
         var message = WebcastLikeMessage.parseFrom(msg);
         var event = new TikTokLikeEvent(message);
         var roomInfoEvent = this.handleRoomInfo(tikTokRoomInfo ->

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

@@ -22,12 +22,13 @@
  */
 package io.github.jwdeveloper.tiktok.websocket;
 
-import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.dto.ProxyData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.data.settings.*;
 import io.github.jwdeveloper.tiktok.exceptions.*;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
+import io.github.jwdeveloper.tiktok.live.LiveMessagesHandler;
 import org.java_websocket.client.WebSocketClient;
 
 import javax.net.ssl.*;
@@ -35,24 +36,25 @@ import java.net.Proxy;
 import java.security.cert.X509Certificate;
 import java.util.HashMap;
 
-public class TikTokWebSocketClient implements SocketClient {
+public class TikTokWebSocketClient implements LiveSocketClient {
     private final LiveClientSettings clientSettings;
-    private final TikTokLiveMessageHandler messageHandler;
-    private final TikTokLiveEventHandler tikTokEventHandler;
-    private WebSocketClient webSocketClient;
-
+    private final LiveMessagesHandler messageHandler;
+    private final LiveEventsHandler tikTokEventHandler;
     private final TikTokWebSocketPingingTask pingingTask;
+    private WebSocketClient webSocketClient;
     private boolean isConnected;
 
     public TikTokWebSocketClient(
             LiveClientSettings clientSettings,
-            TikTokLiveMessageHandler messageHandler,
-            TikTokLiveEventHandler tikTokEventHandler) {
+            LiveMessagesHandler messageHandler,
+            LiveEventsHandler tikTokEventHandler,
+            TikTokWebSocketPingingTask pingingTask)
+    {
         this.clientSettings = clientSettings;
         this.messageHandler = messageHandler;
         this.tikTokEventHandler = tikTokEventHandler;
+        this.pingingTask = pingingTask;
         isConnected = false;
-        pingingTask = new TikTokWebSocketPingingTask();
     }
 
     @Override
@@ -63,7 +65,7 @@ public class TikTokWebSocketClient implements SocketClient {
 
         messageHandler.handle(liveClient, connectionData.getWebcastResponse());
 
-		var headers = new HashMap<>(clientSettings.getHttpSettings().getHeaders());
+        var headers = new HashMap<>(clientSettings.getHttpSettings().getHeaders());
         headers.put("Cookie", connectionData.getWebsocketCookies());
         webSocketClient = new TikTokWebSocketListener(connectionData.getWebsocketUrl(),
                 headers,
@@ -95,9 +97,15 @@ public class TikTokWebSocketClient implements SocketClient {
             if (proxySettings.getType() == Proxy.Type.SOCKS) {
                 SSLContext sc = SSLContext.getInstance("SSL");
                 sc.init(null, new TrustManager[]{new X509TrustManager() {
-                    public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {}
-                    public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {}
-                    public X509Certificate[] getAcceptedIssuers() { return null; }
+                    public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
+                    }
+
+                    public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
+                    }
+
+                    public X509Certificate[] getAcceptedIssuers() {
+                        return null;
+                    }
                 }}, null);
                 webSocketClient.setSocketFactory(sc.getSocketFactory());
             }

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

@@ -23,10 +23,11 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
 import com.google.protobuf.ByteString;
-import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokProtocolBufferException;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
+import io.github.jwdeveloper.tiktok.live.LiveMessagesHandler;
 import io.github.jwdeveloper.tiktok.messages.webcast.*;
 import org.java_websocket.client.WebSocketClient;
 import org.java_websocket.drafts.Draft_6455;
@@ -38,20 +39,20 @@ import java.util.*;
 
 public class TikTokWebSocketListener extends WebSocketClient {
 
-    private final TikTokLiveMessageHandler messageHandler;
-    private final TikTokLiveEventHandler tikTokEventHandler;
-    private final LiveClient tikTokLiveClient;
+    private final LiveMessagesHandler messagesHandler;
+    private final LiveEventsHandler eventHandler;
+    private final LiveClient liveClient;
 
     public TikTokWebSocketListener(URI serverUri,
                                    Map<String, String> httpHeaders,
                                    int connectTimeout,
-                                   TikTokLiveMessageHandler messageHandler,
-                                   TikTokLiveEventHandler tikTokEventHandler,
+                                   LiveMessagesHandler messageHandler,
+                                   LiveEventsHandler tikTokEventHandler,
                                    LiveClient tikTokLiveClient) {
         super(serverUri, new Draft_6455(), httpHeaders, connectTimeout);
-        this.messageHandler = messageHandler;
-        this.tikTokEventHandler = tikTokEventHandler;
-        this.tikTokLiveClient = tikTokLiveClient;
+        this.messagesHandler = messageHandler;
+        this.eventHandler = tikTokEventHandler;
+        this.liveClient = tikTokLiveClient;
     }
 
     @Override
@@ -59,7 +60,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
         try {
             handleBinary(bytes.array());
         } catch (Exception e) {
-            tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(e));
+            eventHandler.publish(liveClient, new TikTokErrorEvent(e));
         }
         if (isOpen()) {
             sendPing();
@@ -83,12 +84,12 @@ public class TikTokWebSocketListener extends WebSocketClient {
                 this.send(pushFrameBuilder.build().toByteArray());
             }
         }
-        messageHandler.handle(tikTokLiveClient, webcastResponse);
+        messagesHandler.handle(liveClient, webcastResponse);
     }
 
     @Override
     public void onOpen(ServerHandshake serverHandshake) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokConnectedEvent());
+        eventHandler.publish(liveClient, new TikTokConnectedEvent());
         if (isOpen()) {
             sendPing();
         }
@@ -96,13 +97,13 @@ public class TikTokWebSocketListener extends WebSocketClient {
 
     @Override
     public void onClose(int code, String reason, boolean remote) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokDisconnectedEvent(reason));
-        tikTokLiveClient.disconnect();
+        eventHandler.publish(liveClient, new TikTokDisconnectedEvent(reason));
+        liveClient.disconnect();
     }
 
     @Override
     public void onError(Exception error) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(error));
+        eventHandler.publish(liveClient, new TikTokErrorEvent(error));
         if (isOpen()) {
             sendPing();
         }
@@ -130,6 +131,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
 
     @Override
     public void onMessage(String s) {
-        // System.err.println(s);
+        //TODO we are not using this method, however I wounder if there might be
+        //so messages that are send as String from TikTok, for example some Jsons
     }
 }

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

@@ -1,17 +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.websocket;
 
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
 import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
 
-public class TikTokWebSocketOfflineClient implements SocketClient {
+public class TikTokWebSocketOfflineClient implements LiveSocketClient {
 
-    private final TikTokLiveEventHandler handler;
+    private final LiveEventsHandler handler;
     private LiveClient liveClient;
 
-    public TikTokWebSocketOfflineClient(TikTokLiveEventHandler handler) {
+    public TikTokWebSocketOfflineClient(LiveEventsHandler handler) {
         this.handler = handler;
     }
 

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

@@ -1,45 +1,59 @@
+/*
+ * 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.websocket;
 
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
 import org.java_websocket.WebSocket;
 
-import java.util.Random;
-
-public class TikTokWebSocketPingingTask
-{
+public class TikTokWebSocketPingingTask {
     private Thread thread;
     private boolean isRunning = false;
     private final int MAX_TIMEOUT = 250;
     private final int SLEEP_TIME = 500;
 
-    public void run(WebSocket webSocket, long pingTaskTime)
-    {
+    public void run(WebSocket webSocket, long pingTaskTime) {
         stop();
-        thread = new Thread(() -> pingTask(webSocket, pingTaskTime));
+        thread = new Thread(() -> pingTask(webSocket, pingTaskTime), "pinging-task");
         isRunning = true;
         thread.start();
     }
 
-    public void stop()
-    {
+    public void stop() {
         if (thread != null)
             thread.interrupt();
         isRunning = false;
     }
 
-    private void pingTask(WebSocket webSocket, long pingTaskTime)
-    {
-        var random = new Random();
+    private void pingTask(WebSocket webSocket, long pingTaskTime) {
         while (isRunning) {
             try {
-                if (!webSocket.isOpen()) {
+                if (webSocket.isOpen()) {
+                    webSocket.sendPing();
+                    Thread.sleep(pingTaskTime + (int) (Math.random() * MAX_TIMEOUT));
+                } else
                     Thread.sleep(SLEEP_TIME);
-                    continue;
-                }
-                webSocket.sendPing();
-
-                Thread.sleep(pingTaskTime+random.nextInt(MAX_TIMEOUT));
-            }
-            catch (Exception e) {
+            } catch (Exception e) {
+                //TODO we should display some kind of error message
                 isRunning = false;
             }
         }

Client/src/test/java/io/github/jwdeveloper/tiktok/TikTokLiveClientTests.java

@@ -0,0 +1,49 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
+import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
+import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
+import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
+import io.github.jwdeveloper.tiktok.data.events.control.TikTokConnectingEvent;
+import io.github.jwdeveloper.tiktok.data.events.control.TikTokPreConnectionEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
+import io.github.jwdeveloper.tiktok.models.ConnectionState;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TikTokLiveClientTests extends TikTokTestBase {
+
+    @Override
+    public void onBeforeEachTest(LiveClientBuilder liveClientBuilder,
+                                         DependanceContainerBuilder containerBuilder) {
+
+
+    }
+
+    @Test
+    public void shouldThrownWhenAlreadyConnected() {
+        roomInfoMock().setConnectionState(ConnectionState.CONNECTED);
+        Assert.assertThrows(TikTokLiveException.class, () ->
+        {
+            liveClient().connect();
+        });
+        Assert.assertEquals(ConnectionState.DISCONNECTED, roomInfoMock().getConnectionState());
+        AssertEvents(
+                TikTokErrorEvent.class,
+                TikTokDisconnectedEvent.class
+        );
+    }
+
+    @Test
+    public void shouldConnect() {
+        liveClient().connect();
+        Assert.assertEquals(ConnectionState.CONNECTED, roomInfoMock().getConnectionState());
+        AssertEvents(
+                TikTokConnectingEvent.class,
+                TikTokPreConnectionEvent.class,
+                TikTokConnectedEvent.class,
+                TikTokRoomInfoEvent.class);
+    }
+}

Client/src/test/java/io/github/jwdeveloper/tiktok/TikTokTestBase.java

@@ -0,0 +1,53 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
+import io.github.jwdeveloper.tiktok.mocks.EventsHandlerMock;
+import lombok.Getter;
+import lombok.experimental.Accessors;
+import org.junit.Before;
+
+/**
+ * Base class for the unit tests
+ */
+
+@Getter
+@Accessors(fluent = true)
+public abstract class TikTokTestBase {
+
+    private LiveClient liveClient;
+
+    private EventsHandlerMock eventsHandlerMock;
+
+    private TikTokRoomInfo roomInfoMock;
+
+    public void AssertEvents(Class<? extends TikTokEvent>... events) {
+        eventsHandlerMock.assertEvents(events);
+    }
+
+    @Before
+    public void setup() {
+
+        var builder = TikTokLive.newClient("test");
+        eventsHandlerMock = new EventsHandlerMock();
+        roomInfoMock = new TikTokRoomInfo();
+        roomInfoMock.setHostName("test");
+        liveClient = builder
+                .configure(liveClientSettings ->
+                {
+                    liveClientSettings.setOffline(true);
+                    liveClientSettings.setFetchGifts(false);
+                })
+                .customize(containerBuilder ->
+                {
+                    containerBuilder.registerSingleton(LiveEventsHandler.class, eventsHandlerMock);
+                    containerBuilder.registerSingleton(TikTokRoomInfo.class, roomInfoMock);
+                    onBeforeEachTest(builder, containerBuilder);
+                }).build();
+    }
+
+    public abstract void onBeforeEachTest(LiveClientBuilder liveClientBuilder, DependanceContainerBuilder containerBuilder);
+}

Client/src/test/java/io/github/jwdeveloper/tiktok/common/TikTokBaseTest.java

@@ -1,55 +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.common;
-
-
-
-import java.io.IOException;
-import java.util.Base64;
-
-public class TikTokBaseTest
-{
-    public byte[] getFileBytes(String path)
-    {
-        try {
-            var stream = getClass().getClassLoader().getResourceAsStream(path);
-            var bytes=  stream.readAllBytes();
-            stream.close();
-            return bytes;
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public byte[] getFileBytesUtf(String path)
-    {
-        try {
-            var stream = getClass().getClassLoader().getResourceAsStream(path);
-            var bytes=  stream.readAllBytes();
-            stream.close();
-            return Base64.getDecoder().decode(bytes);
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
-}

Client/src/test/java/io/github/jwdeveloper/tiktok/gifts/TikTokGiftManagerTest.java

@@ -1,38 +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.gifts;
-
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-
-@ExtendWith(MockitoExtension.class)
-
-public class TikTokGiftManagerTest {
-
-
-
-
-
-
-}

Client/src/test/java/io/github/jwdeveloper/tiktok/listener/TikTokListenersManagerTest.java

@@ -22,7 +22,10 @@
  */
 package io.github.jwdeveloper.tiktok.listener;
 
+import io.github.jwdeveloper.dependance.Dependance;
+import io.github.jwdeveloper.dependance.api.DependanceContainer;
 import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
+import io.github.jwdeveloper.tiktok.annotations.Priority;
 import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
@@ -44,27 +47,34 @@ class TikTokListenersManagerTest {
 
     private TikTokLiveEventHandler eventObserver;
     private TikTokListenersManager tikTokListenersManager;
+    private DependanceContainer dependanceContainer;
+    private LiveClient liveClient;
 
     @BeforeEach
     void setUp() {
-        eventObserver = Mockito.mock(TikTokLiveEventHandler.class);
-        List<TikTokEventListener> listeners = new ArrayList<>();
-        tikTokListenersManager = new TikTokListenersManager(listeners, eventObserver);
+
+        liveClient = Mockito.mock(LiveClient.class);
+        eventObserver = new TikTokLiveEventHandler();
+
+        dependanceContainer = Dependance.newContainer()
+                .registerSingleton(LiveClient.class, liveClient)
+                .build();
+        tikTokListenersManager = new TikTokListenersManager(eventObserver, dependanceContainer);
     }
 
     @Test
     void addListener() {
-        TikTokEventListener listener =new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         tikTokListenersManager.addListener(listener);
 
-        List<TikTokEventListener> listeners = tikTokListenersManager.getListeners();
+        List<Object> listeners = tikTokListenersManager.getListeners();
         assertEquals(1, listeners.size());
         assertSame(listener, listeners.get(0));
     }
 
     @Test
     void addListener_alreadyRegistered_throwsException() {
-        TikTokEventListener listener = new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         tikTokListenersManager.addListener(listener);
 
         Exception exception = assertThrows(TikTokLiveException.class, () -> {
@@ -76,39 +86,56 @@ class TikTokListenersManagerTest {
 
     @Test
     void removeListener() {
-        TikTokEventListener listener = new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         tikTokListenersManager.addListener(listener);
         tikTokListenersManager.removeListener(listener);
 
-        List<TikTokEventListener> listeners = tikTokListenersManager.getListeners();
+        List<Object> listeners = tikTokListenersManager.getListeners();
         assertTrue(listeners.isEmpty());
     }
 
+    @Test
+    public void shouldTriggerEvents() {
+
+        Object listener = new TikTokEventListenerTest();
+        tikTokListenersManager.addListener(listener);
+
+
+        var fakeGiftEvent = TikTokGiftEvent.of("TestRosa", 1, 1);
+        eventObserver.publish(liveClient, fakeGiftEvent);
+    }
+
     @Test
     void removeListener_notRegistered_doesNotThrow() {
-        TikTokEventListener listener = new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         assertDoesNotThrow(() -> tikTokListenersManager.removeListener(listener));
     }
 
 
-    public static class TikTokEventListenerTest implements TikTokEventListener
-    {
+    public static class TikTokEventListenerTest {
         @TikTokEventObserver
-        public void onJoin(LiveClient client, TikTokJoinEvent joinEvent)
-        {
-
+        public void onJoin(LiveClient client, TikTokJoinEvent joinEvent) {
+            System.out.println("Hello from on join" + client + " " + joinEvent);
         }
 
-        @TikTokEventObserver
-        public void onGift(LiveClient client, TikTokGiftEvent giftMessageEvent)
-        {
-
+        @TikTokEventObserver(priority = Priority.LOWEST)
+        public void onGift(LiveClient client, TikTokGiftEvent giftMessageEvent) {
+            System.out.println("Hello from onGift lowest priority" + client + " " + giftMessageEvent);
         }
 
-        @TikTokEventObserver
-        public void onEvent(LiveClient client, TikTokEvent event)
-        {
+        @TikTokEventObserver(priority = Priority.NORMAL)
+        public void onGift2(LiveClient client, TikTokGiftEvent giftMessageEvent) {
+            System.out.println("Hello from onGift normal priority " + client + " " + giftMessageEvent);
+        }
 
+        @TikTokEventObserver(priority = Priority.HIGHEST)
+        public void onGift3(LiveClient client, TikTokGiftEvent giftMessageEvent) {
+            System.out.println("Hello from onGift highest priority " + client + " " + giftMessageEvent);
+        }
+
+        @TikTokEventObserver(async = true)
+        public void onEvent(LiveClient client, TikTokEvent event) {
+            System.out.println("Hello from onEvent im running on the thread " + Thread.currentThread().getName());
         }
     }
 }

Client/src/test/java/io/github/jwdeveloper/tiktok/mocks/EventsHandlerMock.java

@@ -0,0 +1,46 @@
+package io.github.jwdeveloper.tiktok.mocks;
+
+import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Cache published events,
+ */
+public class EventsHandlerMock extends TikTokLiveEventHandler {
+    private final List<TikTokEvent> publishedEvents = new ArrayList<TikTokEvent>();
+
+
+    @Override
+    public void publish(LiveClient tikTokLiveClient, TikTokEvent tikTokEvent) {
+        super.publish(tikTokLiveClient, tikTokEvent);
+        publishedEvents.add(tikTokEvent);
+    }
+
+    @SafeVarargs
+    public final void assertEvents(Class<? extends TikTokEvent>... events) {
+
+        if (events.length == 0 && !publishedEvents.isEmpty()) {
+            var classNames = publishedEvents.stream()
+                    .map(e -> e.getClass().getSimpleName())
+                    .toList();
+            var invokedEvents = String.join("\n", classNames);
+            throw new IllegalArgumentException("Not events should be invoked but there was: \n" + invokedEvents);
+        }
+
+
+        for (var i = 0; i < events.length; i++) {
+            var expectedEvent = events[i];
+            var invokedEvent = publishedEvents.get(i);
+            if (expectedEvent.equals(invokedEvent.getClass())) {
+                continue;
+            }
+            throw new RuntimeException("Expected event was " + expectedEvent + " but acctuall was " + invokedEvent.getClass());
+        }
+
+
+    }
+}

README.md

@@ -70,7 +70,7 @@ Maven
          <dependency>
             <groupId>com.github.jwdeveloper.TikTok-Live-Java</groupId>
             <artifactId>Client</artifactId>
-             <version>1.7.0-Release</version>
+             <version>1.8.0-Release</version>
             <scope>compile</scope>
         </dependency>
    </dependencies>
@@ -426,9 +426,9 @@ Triggered every time gift is sent
   <p>>Combo: 1  -> comboState = GiftSendType.Begin</p>
   <p>Combo: 4 -> comboState = GiftSendType.Active</p>
   <p>Combo: 8 -> comboState = GiftSendType.Active</p>
-  <p>Combo: 12 -> comboState = GiftSendType.Finsihed</p>
+  <p>Combo: 12 -> comboState = GiftSendType.Finished</p>
   <p>
-  Remember if comboState is Finsihed both TikTokGiftComboEvent and TikTokGiftEvent event gets triggered
+  Remember if comboState is Finished both TikTokGiftComboEvent and TikTokGiftEvent event gets triggered
 
 
 ```java
@@ -754,4 +754,4 @@ public static class CustomListener implements TikTokEventListener {
 
 [Library documentation for contributors](https://github.com/jwdeveloper/TikTokLiveJava/wiki)
 
-Your improvements are welcome! Feel free to open an <a href="https://github.com/jwdeveloper/TikTok-Live-Java/issues">issue</a> or <a href="https://github.com/jwdeveloper/TikTok-Live-Java/pulls">pull request</a>.
+Your improvements are welcome! Feel free to open an <a href="https://github.com/jwdeveloper/TikTok-Live-Java/issues">issue</a> or <a href="https://github.com/jwdeveloper/TikTok-Live-Java/pulls">pull request</a>.

examples/pom.xml

@@ -41,12 +41,12 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.7.1-Release</version>
+        <version>1.8.2-Release</version>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>Examples</artifactId>
+    <artifactId>examples</artifactId>
     <dependencies>
         <dependency>
             <groupId>io.github.jwdeveloper.tiktok</groupId>
@@ -75,7 +75,7 @@
         <dependency>
             <groupId>io.github.jwdeveloper.tiktok</groupId>
             <artifactId>extension-collector</artifactId>
-            <version>1.7.1-Release</version>
+            <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

examples/src/main/java/io/github/jwdeveloper/tiktok/ConnectionExample.java

@@ -32,14 +32,11 @@ import java.time.Duration;
 import java.util.logging.Level;
 
 public class ConnectionExample {
-    public static String TIKTOK_HOSTNAME = "kvadromama_marina1";
+    public static String TIKTOK_HOSTNAME = "yttvandroid";
 
     public static void main(String[] args) throws IOException {
 
         showLogo();
-
-        var gifts = TikTokLive.gifts();
-
         TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
                 .configure(clientSettings ->
                 {

examples/src/main/java/io/github/jwdeveloper/tiktok/CustomMappingExample.java

@@ -30,7 +30,7 @@ public class CustomMappingExample {
 
     public static void main(String[] args) {
         TikTokLive.newClient("saszareznikow")
-                .onMapping(mapper ->
+                .mappings(mapper ->
                 {
                     mapper.forMessage(WebcastChatMessage.class)
                             .onBeforeMapping((inputBytes, messageName, mapperHelper) ->
@@ -56,7 +56,6 @@ public class CustomMappingExample {
                                 System.out.println("onAfter mapping, " + source.getClass().getSimpleName() + " was mapped to " + events.size() + " events");
                                 return events;
                             });
-
                     /*
                       There might be cast that we don't have Webcast class for incoming message from TikTok
                       `mapperHelper.bytesToProtoBufferStructure` but you can still investigate message structure

examples/src/main/java/io/github/jwdeveloper/tiktok/CustomizationExample.java

@@ -0,0 +1,44 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
+import io.github.jwdeveloper.tiktok.live.*;
+
+/**
+ * When the default implementation does not meet your needs,
+ * you can override it using `customize` method
+ */
+public class CustomizationExample {
+    public static void main(String[] args) {
+
+        var customEventHandler = new CustomEventsHandler();
+        var client = TikTokLive.newClient("john")
+                .configure(liveClientSettings ->
+                {
+                    liveClientSettings.setFetchGifts(false);
+                    liveClientSettings.setOffline(true);
+                })
+                .onError((liveClient, event) ->
+                {
+                    event.getException().printStackTrace();
+                })
+                .customize(container ->
+                {
+                    //overriding default implementation of LiveEventsHandler, with own one
+                    container.registerSingleton(LiveEventsHandler.class, customEventHandler);
+                }).build();
+
+        client.connect();
+        client.publishEvent(TikTokGiftEvent.of("rose", 1, 12));
+        client.publishEvent(TikTokGiftEvent.of("stone", 2, 12));
+    }
+
+
+    public static class CustomEventsHandler extends TikTokLiveEventHandler {
+
+        @Override
+        public void publish(LiveClient tikTokLiveClient, TikTokEvent tikTokEvent) {
+            System.out.println("Hello from custom events handler: " + tikTokEvent.getClass().getSimpleName());
+        }
+    }
+}

examples/src/main/java/io/github/jwdeveloper/tiktok/Events_And_Gifts_Testing_Example.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;
 
 import io.github.jwdeveloper.tiktok.data.events.TikTokCommentEvent;
@@ -47,9 +69,7 @@ public class Events_And_Gifts_Testing_Example
 
         var fakeGift = TikTokGiftEvent.of(roseGift);
         var fakeComboGift = TikTokGiftComboEvent.of(roseGift, 12, GiftComboStateType.Begin);
-
         var fakeMessage = TikTokCommentEvent.of("Mark", "Hello world");
-
         var fakeSubscriber = TikTokSubscribeEvent.of("Mark");
         var fakeFollow = TikTokFollowEvent.of("Mark");
         var fakeLike = TikTokLikeEvent.of("Mark", 12);

examples/src/main/java/io/github/jwdeveloper/tiktok/GiftsExample.java

@@ -29,8 +29,6 @@ public class GiftsExample {
     public static void main(String[] args) {
         var giftsManager = TikTokLive.gifts();
 
-
-
         var giftsList = giftsManager.toList();
         for (var gift : giftsList) {
             System.out.println("Gift: " + gift);

examples/src/main/java/io/github/jwdeveloper/tiktok/ListenerExample.java

@@ -28,21 +28,18 @@ import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
-import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.utils.ConsoleColors;
 
 import java.io.IOException;
 
-public class ListenerExample
-{
+public class ListenerExample {
     // <code>
+
     /**
-     *
-     *  Listeners are an alternative way of handling events.
-     *  I would to suggest to use then when logic of handing event
-     *  is more complex
-     *
+     * Listeners are an alternative way of handling events.
+     * I would to suggest to use then when logic of handing event
+     * is more complex
      */
     public static void main(String[] args) throws IOException {
         showLogo();
@@ -55,24 +52,21 @@ public class ListenerExample
     }
 
     /**
-     *
-     *  Method in TikTokEventListener should meet 4 requirements to be detected
-     *         - must have @TikTokEventObserver annotation
-     *         - must have 2 parameters
-     *         - first parameter must be LiveClient
-     *         - second must be class that extending TikTokEvent
+     * Method must meet 2 requirements to be detected
+     * - must have @TikTokEventObserver annotation
+     * - must have 1 parameter of type that extending TikTokEvent
      */
 
-    public static class CustomListener implements TikTokEventListener {
+    public static class CustomListener {
 
         @TikTokEventObserver
-        public void onLike(LiveClient liveClient, TikTokLikeEvent event) {
+        public void onLike(TikTokLikeEvent event) {
             System.out.println(event.toString());
         }
 
         @TikTokEventObserver
-        public void onError(LiveClient liveClient, TikTokErrorEvent event) {
-          //  event.getException().printStackTrace();
+        public void onError(TikTokErrorEvent event, LiveClient liveClient) {
+            //  event.getException().printStackTrace();
         }
 
         @TikTokEventObserver
@@ -103,9 +97,8 @@ public class ListenerExample
     }
 
     // </code>
-    private static void showLogo()
-    {
-        System.out.println(ConsoleColors.GREEN+"""
+    private static void showLogo() {
+        System.out.println(ConsoleColors.GREEN + """
                                 
                  _____ _ _    _____     _    _     _          \s
                 |_   _(_) | _|_   _|__ | | _| |   (_)_   _____\s

examples/src/main/java/io/github/jwdeveloper/tiktok/RecorderExample.java

@@ -32,6 +32,7 @@ public class RecorderExample {
 
     public static void main(String[] args) {
 
+
         TikTokLive.newClient("bangbetmenygy")
                 .configure(liveClientSettings ->
                 {

extension-collector/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
         <artifactId>TikTokLiveJava</artifactId>
-        <version>1.7.1-Release</version>
+        <version>1.8.2-Release</version>
     </parent>
 
 
@@ -33,7 +33,7 @@
         <dependency>
             <groupId>io.github.jwdeveloper.tiktok</groupId>
             <artifactId>API</artifactId>
-            <version>1.7.1-Release</version>
+            <version>1.8.2-Release</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

extension-collector/src/main/java/io/github/jwdeveloper/tiktok/extension/collector/api/CollectorEvent.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.extension.collector.api;
 
 import io.github.jwdeveloper.tiktok.live.LiveClient;