Created TikTokLiveUnknownHostException for use inside of TikTokLiveClient!

- rename TikTokMapper to LiveMapper
- rename TikTokLiveMapperHelper to LiveMapperHelper

Create interface:
LiveEventsHandler for TikTokLiveEventHandler
LiveMessagesHandler for TikTokLiveMessageHandler

API/pom.xml

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

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 {

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

@@ -25,9 +25,6 @@ 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
 {

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 {

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

@@ -28,9 +28,6 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokLiveClientEvent;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
-/**
- * General error event. You should handle this.
- */
 @Getter
 @AllArgsConstructor
 @EventMeta(eventType = EventType.Control)

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

@@ -26,9 +26,7 @@ import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 
 
-/**
- * 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 {
 }

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 {

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/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/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,9 +29,7 @@ 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

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

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

@@ -29,9 +29,7 @@ import io.github.jwdeveloper.tiktok.data.models.users.User;
 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 {

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,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;
 
 public abstract class Team {

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;

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;

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;

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

@@ -33,6 +33,7 @@ import java.util.List;
 public interface ListenersManager
 {
     List<TikTokEventListener> getListeners();
+
     void addListener(TikTokEventListener listener);
 
     void removeListener(TikTokEventListener listener);

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,8 @@
  */
 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.TikTokPreConnectionEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
@@ -36,6 +36,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 +53,257 @@ 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);
+    }
 
     /**
      * 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 +350,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,10 +22,11 @@
  */
 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;
@@ -41,7 +42,7 @@ public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
      * @param onCustomMappings lambda method
      * @return
      */
-    LiveClientBuilder onMapping(Consumer<TikTokMapper> onCustomMappings);
+    LiveClientBuilder onMapping(Consumer<LiveMapper> onCustomMappings);
 
 
     /**
@@ -60,15 +61,26 @@ public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
      */
     LiveClientBuilder addListener(TikTokEventListener 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();
 
     /**
-     *
-     * @return LiveClient object and connects to TikTok live
+     * Builds new instance of the LiveClient and connects to live
+     * @return LiveClient object
      */
     LiveClient buildAndConnect();
 

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);
 
 }

Client/pom.xml

@@ -5,13 +5,14 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.6.4-Release</version>
+        <version>1.8.0-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

@@ -37,36 +37,39 @@ 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 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 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,
+            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,15 +78,10 @@ public class TikTokLiveClient implements LiveClient {
         this.logger = logger;
     }
 
-
     public void connectAsync(Consumer<LiveClient> onConnection) {
-        CompletableFuture.runAsync(() -> {
-            connect();
-            onConnection.accept(this);
-        });
+        connectAsync().thenAccept(onConnection);
     }
 
-
     public CompletableFuture<LiveClient> connectAsync() {
         return CompletableFuture.supplyAsync(() -> {
             connect();
@@ -117,61 +115,61 @@ 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 +178,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 +199,4 @@ public class TikTokLiveClient implements LiveClient {
         messageHandler.handleSingleMessage(this, message);
     }
 
-    @Override
-    public GiftsManager getGiftManager() {
-        return giftsManager;
-    }
-
-    public LiveRoomInfo getRoomInfo() {
-        return liveRoomInfo;
-    }
-
-    @Override
-    public ListenersManager getListenersManager() {
-        return listenersManager;
-    }
-
-    @Override
-    public Logger getLogger() {
-        return logger;
-    }
 }

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,25 @@ 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 LiveEventsHandler eventHandler;
     protected final List<TikTokEventListener> listeners;
-    protected Consumer<TikTokMapper> onCustomMappings;
-    protected Logger logger;
-    protected GiftsManager giftsManager;
+    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 onMapping(Consumer<LiveMapper> consumer) {
+        this.onCustomMappings.add(consumer);
         return this;
     }
 
@@ -88,6 +81,12 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         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");
@@ -104,169 +103,84 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         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.registerSingletonList(TikTokEventListener.class, (e) -> 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(SocketClient.class, TikTokWebSocketOfflineClient.class);
+            dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpOfflineClient.class);
+        } else {
+            dependance.registerSingleton(SocketClient.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();
+        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 +191,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) {
@@ -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) {

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.*;
@@ -100,8 +122,8 @@ public class ActionResult<T> {
 	public JsonObject toJson() {
 		JsonObject map = new JsonObject();
 		map.addProperty("success", success);
-		map.add("content", gson.toJsonTree(content));
 		map.addProperty("message", message);
+		map.add("content", gson.toJsonTree(content));
 		map.add("previous", hasPrevious() ? previous.toJson() : null);
 		return map;
 	}

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

@@ -29,6 +29,7 @@ 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;
@@ -37,10 +38,10 @@ import java.util.HashMap;
 import java.util.List;
 
 public class TikTokListenersManager implements ListenersManager {
-    private final TikTokLiveEventHandler eventObserver;
+    private final LiveEventsHandler eventObserver;
     private final List<ListenerBindingModel> bindingModels;
 
-    public TikTokListenersManager(List<TikTokEventListener> listeners, TikTokLiveEventHandler tikTokEventHandler) {
+    public TikTokListenersManager(List<TikTokEventListener> listeners, LiveEventsHandler tikTokEventHandler) {
         this.eventObserver = tikTokEventHandler;
         this.bindingModels = new ArrayList<>(listeners.size());
         for (var listener : listeners) {

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 {
 
@@ -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("parseFrom", 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,23 +23,19 @@
 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;
 
-    public TikTokLiveMapper(TikTokMapperHelper mapperUtils) {
+    public TikTokLiveMapper(LiveMapperHelper mapperUtils) {
         this.mappers = new HashMap<>();
         this.mapperUtils = mapperUtils;
         this.globalMapperModel = new TikTokLiveMapperModel("any message");
@@ -47,11 +43,7 @@ public class TikTokLiveMapper implements TikTokMapper {
 
     @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 +58,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 +75,6 @@ public class TikTokLiveMapper implements TikTokMapper {
         return globalMapperModel;
     }
 
-
     public boolean isRegistered(String mapperName) {
         return mappers.containsKey(mapperName);
     }
@@ -94,23 +84,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,7 @@ 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 final TikTokGenericEventMapper genericMapper;
 
     public TikTokLiveMapperHelper(TikTokGenericEventMapper genericMapper) {

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;
@@ -48,18 +48,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 +62,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 +75,6 @@ public class TikTokGiftEventHandler {
             }
         }
 
-        var previousMessage = giftsMessages.get(userId);
         var previousType = GiftComboStateType.fromNumber(previousMessage.getSendType());
         if (currentType == GiftComboStateType.Active &&
                 previousType == GiftComboStateType.Active) {
@@ -114,9 +112,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,15 @@
  */
 package io.github.jwdeveloper.tiktok.websocket;
 
+import io.github.jwdeveloper.dependance.injector.api.containers.Container;
 import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.dto.ProxyData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 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.*;
@@ -37,22 +40,23 @@ import java.util.HashMap;
 
 public class TikTokWebSocketClient implements SocketClient {
     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 +67,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 +99,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

@@ -27,6 +27,8 @@ 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,15 +40,15 @@ import java.util.*;
 
 public class TikTokWebSocketListener extends WebSocketClient {
 
-    private final TikTokLiveMessageHandler messageHandler;
-    private final TikTokLiveEventHandler tikTokEventHandler;
+    private final LiveMessagesHandler messageHandler;
+    private final LiveEventsHandler tikTokEventHandler;
     private final LiveClient tikTokLiveClient;
 
     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;

Client/src/main/java/io/github/jwdeveloper/tiktok/websocket/TikTokWebSocketOfflineClient.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.websocket;
 
 import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
@@ -5,13 +27,14 @@ 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 {
 
-    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/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 {
-
-
-
-
-
-
-}

Examples/pom.xml

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

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

@@ -32,7 +32,7 @@ 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 {
 

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

@@ -26,6 +26,8 @@ package io.github.jwdeveloper.tiktok;
 import io.github.jwdeveloper.tiktok.extension.recorder.TikTokLiveRecorder;
 import io.github.jwdeveloper.tiktok.extension.recorder.impl.event.TikTokLiveRecorderStartedEvent;
 
+import java.io.File;
+
 public class RecorderExample {
 
     public static void main(String[] args) {
@@ -39,11 +41,10 @@ public class RecorderExample {
                 {
                     event.getException().printStackTrace();
                 })
-                .addListener(TikTokLiveRecorder.use(recorderSettings ->
+                .addListener(TikTokLiveRecorder.use((recorderSettings, liveClient) ->
                 {
                     recorderSettings.setFfmpegPath("C:\\Users\\ja\\IdeaProjects\\TikTokLiveJava\\extension-recorder\\libs\\ffmpeg.exe");
-                    recorderSettings.setOutputPath("C:\\Users\\ja\\IdeaProjects\\TikTokLiveJava\\extension-recorder\\out");
-                    recorderSettings.setOutputFileName("test.flv");
+                    recorderSettings.setOutputFile(new File("C:\\Users\\ja\\IdeaProjects\\TikTokLiveJava\\extension-recorder\\out", "test.flv"));
                 }))
                 .onEvent(TikTokLiveRecorderStartedEvent.class, (liveClient, event) ->
                 {

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

extension-collector/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
         <artifactId>TikTokLiveJava</artifactId>
-        <version>1.6.4-Release</version>
+        <version>1.8.0-Release</version>
     </parent>
 
 
@@ -33,7 +33,7 @@
         <dependency>
             <groupId>io.github.jwdeveloper.tiktok</groupId>
             <artifactId>API</artifactId>
-            <version>1.6.4-Release</version>
+            <version>1.8.0-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;

extension-collector/src/main/java/io/github/jwdeveloper/tiktok/extension/collector/api/Storage.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 org.bson.Document;

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

extension-collector/src/main/java/io/github/jwdeveloper/tiktok/extension/collector/impl/DataCollectorListener.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.impl;
 
 import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;

extension-collector/src/main/java/io/github/jwdeveloper/tiktok/extension/collector/impl/storages/FileStorage.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.impl.storages;
 
 import io.github.jwdeveloper.tiktok.extension.collector.api.Storage;

extension-collector/src/main/java/io/github/jwdeveloper/tiktok/extension/collector/impl/storages/MongoStorage.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.impl.storages;
 
 import com.mongodb.ConnectionString;

extension-recorder/pom.xml

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

extension-recorder/src/main/java/io/github/jwdeveloper/tiktok/extension/recorder/TikTokLiveRecorder.java

@@ -25,18 +25,19 @@ package io.github.jwdeveloper.tiktok.extension.recorder;
 import io.github.jwdeveloper.tiktok.extension.recorder.api.LiveRecorder;
 import io.github.jwdeveloper.tiktok.extension.recorder.impl.RecorderListener;
 import io.github.jwdeveloper.tiktok.extension.recorder.impl.data.RecorderSettings;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
 
-import java.util.function.Consumer;
+import java.util.function.*;
 
 public class TikTokLiveRecorder
 {
-    public static LiveRecorder use(Consumer<RecorderSettings> consumer)
+    public static LiveRecorder use(BiConsumer<RecorderSettings, LiveClient> consumer)
     {
         return new RecorderListener(consumer);
     }
 
     public static LiveRecorder use()
     {
-        return use(x ->{});
+        return use((x,y) ->{});
     }
 }

extension-recorder/src/main/java/io/github/jwdeveloper/tiktok/extension/recorder/impl/RecorderListener.java

@@ -37,26 +37,23 @@ import io.github.jwdeveloper.tiktok.models.ConnectionState;
 import javax.net.ssl.HttpsURLConnection;
 import java.io.*;
 import java.net.URL;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
-
-import static java.nio.charset.StandardCharsets.UTF_8;
+import java.util.function.*;
 
 public class RecorderListener implements LiveRecorder {
 
-    private final Consumer<RecorderSettings> consumer;
+    private final BiConsumer<RecorderSettings, LiveClient> consumer;
     private RecorderSettings settings;
     private DownloadData downloadData;
     private Thread liveDownloadThread;
 
-    public RecorderListener(Consumer<RecorderSettings> consumer) {
+    public RecorderListener(BiConsumer<RecorderSettings, LiveClient> consumer) {
         this.consumer = consumer;
     }
 
     @TikTokEventObserver
     private void onResponse(LiveClient liveClient, TikTokRoomDataResponseEvent event) {
         settings = RecorderSettings.DEFAULT();
-        consumer.accept(settings);
+        consumer.accept(settings, liveClient);
 
         var json = event.getLiveData().getJson();
 
@@ -76,10 +73,9 @@ public class RecorderListener implements LiveRecorder {
         if (isConnected())
             return;
 
-
         liveDownloadThread = new Thread(() -> {
             try {
-                liveClient.getLogger().info("Recording started");
+                liveClient.getLogger().info("Recording started "+liveClient.getRoomInfo().getHostName());
                 var url = new URL(downloadData.getFullUrl());
                 HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
                 var headers = LiveClientSettings.DefaultRequestHeaders();
@@ -87,18 +83,17 @@ public class RecorderListener implements LiveRecorder {
                     connection.setRequestProperty(entry.getKey(), entry.getValue());
                 }
 
-                var path = settings.getOutputPath() + File.separator + settings.getOutputFileName();
-                var file = new File(path);
+                var file = settings.getOutputFile();
                 file.getParentFile().mkdirs();
                 file.createNewFile();
 
                 try (
-                        var in = connection.getInputStream();
-                        var fos = new FileOutputStream(file)
+                    var in = connection.getInputStream();
+                    var fos = new FileOutputStream(file)
                 ) {
                     byte[] dataBuffer = new byte[1024];
                     int bytesRead;
-                    while (liveClient.getRoomInfo().getConnectionState() == ConnectionState.CONNECTED && (bytesRead = in.read(dataBuffer)) != -1) {
+                    while ((!settings.isStopOnDisconnect() || liveClient.getRoomInfo().getConnectionState() == ConnectionState.CONNECTED) && (bytesRead = in.read(dataBuffer)) != -1) {
                         fos.write(dataBuffer, 0, bytesRead);
                         fos.flush();
                     }
@@ -113,11 +108,10 @@ public class RecorderListener implements LiveRecorder {
 
         var recordingStartedEvent = new TikTokLiveRecorderStartedEvent(downloadData);
         liveClient.publishEvent(recordingStartedEvent);
-        if (recordingStartedEvent.isCanceled()) {
-            liveClient.getLogger().info("Recording cancelled");
-            return;
-        }
-        liveDownloadThread.start();
+        if (recordingStartedEvent.isCanceled())
+			liveClient.getLogger().info("Recording cancelled");
+		else
+            liveDownloadThread.start();
     }
 
     @TikTokEventObserver

extension-recorder/src/main/java/io/github/jwdeveloper/tiktok/extension/recorder/impl/data/RecorderSettings.java

@@ -27,6 +27,7 @@ import io.github.jwdeveloper.tiktok.extension.recorder.impl.enums.LiveFormat;
 import lombok.Getter;
 import lombok.Setter;
 
+import java.io.File;
 import java.util.function.Function;
 
 @Getter
@@ -36,10 +37,8 @@ public class RecorderSettings {
     private String ffmpegPath;
     private String quality;
     private String format;
-    private String outputPath;
-    private String outputFileName;
+    private File outputFile;
     private Function<String,DownloadData> prepareDownloadData;
-    private boolean startOnConnected;
     private boolean stopOnDisconnect = true;
 
     public static RecorderSettings DEFAULT() {

pom.xml

@@ -7,12 +7,12 @@
     <groupId>io.github.jwdeveloper.tiktok</groupId>
     <artifactId>TikTokLiveJava</artifactId>
     <packaging>pom</packaging>
-    <version>1.6.4-Release</version>
+    <version>1.8.0-Release</version>
     <modules>
         <module>API</module>
         <module>Client</module>
         <module>Examples</module>
-        <module>Tools-ReadmeGenerator</module>
+        <module>tools-readme</module>
 
         <module>extension-recorder</module>
         <module>extension-collector</module>
@@ -23,7 +23,12 @@
         <maven.compiler.target>16</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
-
+    <repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+    </repositories>
     <build>
         <plugins>
             <plugin>
@@ -74,6 +79,12 @@
     </build>
 
     <dependencies>
+        <dependency>
+            <groupId>com.github.jwdeveloper.DepenDance</groupId>
+            <artifactId>DepenDance-Full</artifactId>
+            <version>0.0.18-Release</version>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>

tools-readme/pom.xml

@@ -5,11 +5,11 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.6.4-Release</version>
+        <version>1.8.0-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>Tools-ReadmeGenerator</artifactId>
+    <artifactId>tools-readme</artifactId>
     <repositories>
         <repository>
             <id>jitpack.io</id>
@@ -23,10 +23,21 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>com.hubspot.jinjava</groupId>
+            <artifactId>jinjava</artifactId>
+            <version>2.7.2</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.13.0</version>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>com.github.jwdeveloper.Descrabble</groupId>
             <artifactId>Descrabble-Full</artifactId>
-            <version>0.0.7-Release</version>
+            <version>0.0.11-Release</version>
             <scope>compile</scope>
         </dependency>
         <dependency>

tools-readme/readme.md

@@ -0,0 +1,3 @@
+Generates documentation from template 
+that can be found under 
+- `src/main/resources/readme-template.html`

tools-readme/src/main/java/io/github/jwdeveloper/tiktok/EventsDecorator.java

@@ -0,0 +1,17 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.descrabble.api.DescriptionDecorator;
+import io.github.jwdeveloper.descrabble.api.elements.Element;
+import io.github.jwdeveloper.descrabble.api.elements.ElementFactory;
+
+public class EventsDecorator implements DescriptionDecorator {
+
+
+
+
+    @Override
+    public void decorate(Element root, ElementFactory factory)
+    {
+
+    }
+}

tools-readme/src/main/java/io/github/jwdeveloper/tiktok/Main.java

@@ -0,0 +1,38 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.descrabble.api.DescriptionGenerator;
+import io.github.jwdeveloper.descrabble.framework.Descrabble;
+import io.github.jwdeveloper.descrabble.plugin.github.DescrabbleGithub;
+import org.apache.commons.io.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Main
+{
+    public static void main(String[] args) throws IOException {
+        var version = System.getenv("VERSION");
+        if (version == null || version.equals("")) {
+            version = "[Replace with current version]";
+        }
+
+        var inputStream = Main.class.getResourceAsStream("/readme-template.html");
+        var targetFile = new File("temp.file");
+        FileUtils.copyInputStreamToFile(inputStream, targetFile);
+
+        var output = System.getProperty("user.dir");
+
+
+        DescriptionGenerator generator = Descrabble.create()
+                .withTemplate(targetFile)
+                .withVariable("version", version)
+                .withDecorator(new EventsDecorator())
+                .withPlugin(DescrabbleGithub.plugin("README.md"))
+                .build();
+
+
+        generator.generate(output);
+        targetFile.delete();
+        inputStream.close();
+    }
+}