MINOR

MINOR update

API/pom.xml

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

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

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

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

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

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

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

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

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

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

@@ -24,10 +24,8 @@ package io.github.jwdeveloper.tiktok.data.events.social;
 
 import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
-import io.github.jwdeveloper.tiktok.data.events.TikTokSubscribeEvent;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastMemberMessage;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSocialMessage;
 import lombok.Value;
 
@@ -47,12 +45,4 @@ public class TikTokFollowEvent extends TikTokHeaderEvent
     totalFollowers = msg.getFollowCount();
   }
 
-    public static TikTokFollowEvent of(String userName)
-    {
-        return new TikTokFollowEvent(WebcastSocialMessage.newBuilder()
-                .setUser(io.github.jwdeveloper.tiktok.messages.data.User.newBuilder()
-                        .setNickname(userName)
-                        .build())
-                .build());
-    }
 }

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

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

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

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

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

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

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

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

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

@@ -35,20 +35,10 @@ public class LiveClientSettings {
 
 
     /**
-     * TODO: give better description
-     * <p>
-     *  sets client in the offline mode, so it do not connects to TikTok servers
-     *  it makes sense to use it when you are testing client with your custom events
-     */
-    private boolean offline;
-
-    /**
-     * TODO: give better description
-     * <p>
      * Determines if gifts data is downloaded before TikTokLive starts,
      * when `false` then client.giftManager() does not contain initial gifts
      */
-    private boolean fetchGifts = true;
+    private boolean fetchGifts;
 
     /**
      * ISO-Language for Client
@@ -86,13 +76,14 @@ public class LiveClientSettings {
     private HttpClientSettings httpSettings;
 
     /**
-     * Optional: Sometimes not every messages from chat are send to TikTokLiveJava to fix this issue you can set sessionId
-     * documentation how to obtain sessionId https://github.com/isaackogan/TikTok-Live-Connector#send-chat-messages
+     *  Optional: Sometimes not every messages from chat are send to TikTokLiveJava to fix this issue you can set sessionId
+     *  documentation how to obtain sessionId https://github.com/isaackogan/TikTok-Live-Connector#send-chat-messages
      */
     private String sessionId;
 
     /**
      * Optional: By default roomID is fetched before connect to live, but you can set it manually
+     *
      */
     private String roomId;
 
@@ -101,7 +92,8 @@ public class LiveClientSettings {
      */
     private String apiKey;
 
-    public static LiveClientSettings createDefault() {
+    public static LiveClientSettings createDefault()
+    {
         var httpSettings = new HttpClientSettings();
         httpSettings.getParams().putAll(DefaultClientParams());
         httpSettings.getHeaders().putAll(DefaultRequestHeaders());
@@ -174,6 +166,4 @@ public class LiveClientSettings {
         headers.put("Accept-Language", "en-US,en; q=0.9");
         return headers;
     }
-
-
 }

Client/pom.xml

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

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

@@ -33,7 +33,6 @@ import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
 import io.github.jwdeveloper.tiktok.exceptions.*;
-import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
 import io.github.jwdeveloper.tiktok.listener.ListenersManager;
 import io.github.jwdeveloper.tiktok.listener.TikTokListenersManager;
 import io.github.jwdeveloper.tiktok.live.GiftsManager;
@@ -49,7 +48,7 @@ import java.util.logging.Logger;
 
 public class TikTokLiveClient implements LiveClient {
     private final TikTokRoomInfo liveRoomInfo;
-    private final LiveHttpClient httpClient;
+    private final TikTokLiveHttpClient httpClient;
     private final SocketClient webSocketClient;
     private final TikTokLiveEventHandler tikTokEventHandler;
     private final LiveClientSettings clientSettings;
@@ -59,7 +58,7 @@ public class TikTokLiveClient implements LiveClient {
 
     public TikTokLiveClient(GiftsManager giftsManager,
                             TikTokRoomInfo tikTokLiveMeta,
-                            LiveHttpClient tiktokHttpClient,
+                            TikTokLiveHttpClient tiktokHttpClient,
                             SocketClient webSocketClient,
                             TikTokLiveEventHandler tikTokEventHandler,
                             LiveClientSettings clientSettings,

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

@@ -45,7 +45,6 @@ import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
 import io.github.jwdeveloper.tiktok.mappers.handlers.*;
 import io.github.jwdeveloper.tiktok.messages.webcast.*;
 import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;
-import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketOfflineClient;
 
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
@@ -55,7 +54,7 @@ import java.util.logging.Logger;
 public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
     protected final LiveClientSettings clientSettings;
-    protected final TikTokLiveEventHandler eventHandler;
+    protected final TikTokLiveEventHandler tikTokEventHandler;
     protected final List<TikTokEventListener> listeners;
     protected Consumer<TikTokMapper> onCustomMappings;
     protected Logger logger;
@@ -64,7 +63,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
     public TikTokLiveClientBuilder(String userName) {
         this.clientSettings = LiveClientSettings.createDefault();
         this.clientSettings.setHostName(userName);
-        this.eventHandler = new TikTokLiveEventHandler();
+        this.tikTokEventHandler = new TikTokLiveEventHandler();
         this.listeners = new ArrayList<>();
         this.onCustomMappings = (e) -> {
         };
@@ -110,30 +109,27 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         var tiktokRoomInfo = new TikTokRoomInfo();
         tiktokRoomInfo.setHostName(clientSettings.getHostName());
 
-        var listenerManager = new TikTokListenersManager(listeners, eventHandler);
+        var listenerManager = new TikTokListenersManager(listeners, tikTokEventHandler);
 
         var httpClientFactory = new HttpClientFactory(clientSettings);
+        var tikTokLiveHttpClient = new TikTokLiveHttpClient(httpClientFactory, clientSettings);
 
-        var liveHttpClient = clientSettings.isOffline() ?
-                new TikTokLiveHttpOfflineClient() :
-                new TikTokLiveHttpClient(httpClientFactory, clientSettings);
 
         var eventsMapper = createMapper(giftsManager, tiktokRoomInfo);
-        var messageHandler = new TikTokLiveMessageHandler(eventHandler, eventsMapper);
+        var messageHandler = new TikTokLiveMessageHandler(tikTokEventHandler, eventsMapper);
 
-        var webSocketClient = clientSettings.isOffline() ?
-                new TikTokWebSocketOfflineClient(eventHandler) :
-                new TikTokWebSocketClient(
-                        clientSettings,
-                        messageHandler,
-                        eventHandler);
+
+        var webSocketClient = new TikTokWebSocketClient(
+                clientSettings,
+                messageHandler,
+                tikTokEventHandler);
 
         return new TikTokLiveClient(
                 giftsManager,
                 tiktokRoomInfo,
-                liveHttpClient,
+                tikTokLiveHttpClient,
                 webSocketClient,
-                eventHandler,
+                tikTokEventHandler,
                 clientSettings,
                 listenerManager,
                 logger);
@@ -239,255 +235,255 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
     }
 
     public TikTokLiveClientBuilder onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
         return this;
     }
 
     public LiveClientBuilder onChest(EventConsumer<TikTokChestEvent> event) {
-        eventHandler.subscribe(TikTokChestEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokChestEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicFanTicket(EventConsumer<TikTokLinkMicFanTicketEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onEnvelope(EventConsumer<TikTokEnvelopeEvent> event) {
-        eventHandler.subscribe(TikTokEnvelopeEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onShop(EventConsumer<TikTokShopEvent> event) {
-        eventHandler.subscribe(TikTokShopEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokShopEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onDetect(EventConsumer<TikTokDetectEvent> event) {
-        eventHandler.subscribe(TikTokDetectEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokDetectEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkLayer(EventConsumer<TikTokLinkLayerEvent> event) {
-        eventHandler.subscribe(TikTokLinkLayerEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLinkLayerEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onConnected(EventConsumer<TikTokConnectedEvent> event) {
-        eventHandler.subscribe(TikTokConnectedEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokConnectedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onPreConnection(EventConsumer<TikTokPreConnectionEvent> event) {
-        eventHandler.subscribe(TikTokPreConnectionEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokPreConnectionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onCaption(EventConsumer<TikTokCaptionEvent> event) {
-        eventHandler.subscribe(TikTokCaptionEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokCaptionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onQuestion(EventConsumer<TikTokQuestionEvent> event) {
-        eventHandler.subscribe(TikTokQuestionEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokQuestionEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRoomPin(EventConsumer<TikTokRoomPinEvent> event) {
-        eventHandler.subscribe(TikTokRoomPinEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokRoomPinEvent.class, event);
         return this;
     }
 
     @Override
     public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> event) {
-        eventHandler.subscribe(eventClass, event);
+        tikTokEventHandler.subscribe(eventClass, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
-        eventHandler.subscribe(TikTokRoomInfoEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokRoomInfoEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
-        eventHandler.subscribe(TikTokLivePausedEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLivePausedEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
-        eventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
-        eventHandler.subscribe(TikTokLikeEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLink(EventConsumer<TikTokLinkEvent> event) {
-        eventHandler.subscribe(TikTokLinkEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLinkEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onBarrage(EventConsumer<TikTokBarrageEvent> event) {
-        eventHandler.subscribe(TikTokBarrageEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokBarrageEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onGift(EventConsumer<TikTokGiftEvent> event) {
-        eventHandler.subscribe(TikTokGiftEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokGiftEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onGiftCombo(EventConsumer<TikTokGiftComboEvent> event) {
-        eventHandler.subscribe(TikTokGiftComboEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokGiftComboEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicArmies(EventConsumer<TikTokLinkMicArmiesEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onEmote(EventConsumer<TikTokEmoteEvent> event) {
-        eventHandler.subscribe(TikTokEmoteEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokEmoteEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnauthorizedMember(EventConsumer<TikTokUnauthorizedMemberEvent> event) {
-        eventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onInRoomBanner(EventConsumer<TikTokInRoomBannerEvent> event) {
-        eventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicMethod(EventConsumer<TikTokLinkMicMethodEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onSubscribe(EventConsumer<TikTokSubscribeEvent> event) {
-        eventHandler.subscribe(TikTokSubscribeEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokSubscribeEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onPoll(EventConsumer<TikTokPollEvent> event) {
-        eventHandler.subscribe(TikTokPollEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokPollEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onFollow(EventConsumer<TikTokFollowEvent> event) {
-        eventHandler.subscribe(TikTokFollowEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokFollowEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
-        eventHandler.subscribe(TikTokCommentEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
         return this;
     }
 
     @Override
     public LiveClientBuilder onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
-        eventHandler.subscribe(TikTokHttpResponseEvent.class, action);
+        tikTokEventHandler.subscribe(TikTokHttpResponseEvent.class, action);
         return this;
     }
 
     public TikTokLiveClientBuilder onGoalUpdate(EventConsumer<TikTokGoalUpdateEvent> event) {
-        eventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRankUpdate(EventConsumer<TikTokRankUpdateEvent> event) {
-        eventHandler.subscribe(TikTokRankUpdateEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onIMDelete(EventConsumer<TikTokIMDeleteEvent> event) {
-        eventHandler.subscribe(TikTokIMDeleteEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event) {
-        eventHandler.subscribe(TikTokLiveEndedEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLiveEndedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onError(EventConsumer<TikTokErrorEvent> event) {
-        eventHandler.subscribe(TikTokErrorEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokErrorEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onJoin(EventConsumer<TikTokJoinEvent> event) {
-        eventHandler.subscribe(TikTokJoinEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokJoinEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onRankText(EventConsumer<TikTokRankTextEvent> event) {
-        eventHandler.subscribe(TikTokRankTextEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokRankTextEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onShare(EventConsumer<TikTokShareEvent> event) {
-        eventHandler.subscribe(TikTokShareEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokShareEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnhandledMember(EventConsumer<TikTokUnhandledMemberEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onSubNotify(EventConsumer<TikTokSubNotifyEvent> event) {
-        eventHandler.subscribe(TikTokSubNotifyEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onLinkMicBattle(EventConsumer<TikTokLinkMicBattleEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onDisconnected(EventConsumer<TikTokDisconnectedEvent> event) {
-        eventHandler.subscribe(TikTokDisconnectedEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnhandledControl(EventConsumer<TikTokUnhandledControlEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onEvent(EventConsumer<TikTokEvent> event) {
-        eventHandler.subscribe(TikTokEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
         return this;
     }
 
     @Override
     public TikTokLiveClientBuilder onReconnecting(EventConsumer<TikTokReconnectingEvent> event) {
-        eventHandler.subscribe(TikTokReconnectingEvent.class, event);
+        tikTokEventHandler.subscribe(TikTokReconnectingEvent.class, event);
         return this;
     }
 }

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

@@ -1,45 +0,0 @@
-package io.github.jwdeveloper.tiktok;
-
-import io.github.jwdeveloper.tiktok.data.models.Picture;
-import io.github.jwdeveloper.tiktok.data.models.users.User;
-import io.github.jwdeveloper.tiktok.data.requests.GiftsData;
-import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
-import io.github.jwdeveloper.tiktok.data.requests.LiveData;
-import io.github.jwdeveloper.tiktok.data.requests.LiveUserData;
-import io.github.jwdeveloper.tiktok.http.LiveHttpClient;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
-
-import java.net.URI;
-import java.util.List;
-
-public class TikTokLiveHttpOfflineClient implements LiveHttpClient {
-    @Override
-    public GiftsData.Response fetchGiftsData() {
-        return new GiftsData.Response("", List.of());
-    }
-
-    @Override
-    public LiveUserData.Response fetchLiveUserData(LiveUserData.Request request) {
-        return new LiveUserData.Response("", LiveUserData.UserStatus.Live, "offline_room_id", 0);
-    }
-
-    @Override
-    public LiveData.Response fetchLiveData(LiveData.Request request) {
-        return new LiveData.Response("",
-                LiveData.LiveStatus.HostOnline,
-                "offline live",
-                0,
-                0,
-                0,
-                false,
-                new User(0L, "offline user", new Picture("")),
-                LiveData.LiveType.SOLO);
-    }
-
-    @Override
-    public LiveConnectionData.Response fetchLiveConnectionData(LiveConnectionData.Request request) {
-        return new LiveConnectionData.Response("",
-                URI.create("https://example.live"),
-                WebcastResponse.newBuilder().build());
-    }
-}

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

@@ -58,40 +58,40 @@ public class TikTokGiftEventHandler {
 
     public List<TikTokEvent> handleGift(WebcastGiftMessage currentMessage) {
         var userId = currentMessage.getUser().getId();
-        var currentType = GiftComboStateType.fromNumber(currentMessage.getSendType());
+        var currentType = GiftSendType.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);
+            var comboEvent = getGiftComboEvent(currentMessage, GiftSendType.Finished);
             var giftEvent = getGiftEvent(currentMessage);
             return List.of(comboEvent, giftEvent);
         }
 
         if (!containsPreviousMessage) {
-            if (currentType == GiftComboStateType.Finished) {
+            if (currentType == GiftSendType.Finished) {
                 return List.of(getGiftEvent(currentMessage));
             } else {
                 giftsMessages.put(userId, currentMessage);
-                return List.of(getGiftComboEvent(currentMessage, GiftComboStateType.Begin));
+                return List.of(getGiftComboEvent(currentMessage, GiftSendType.Begin));
             }
         }
 
         var previousMessage = giftsMessages.get(userId);
-        var previousType = GiftComboStateType.fromNumber(previousMessage.getSendType());
-        if (currentType == GiftComboStateType.Active &&
-                previousType == GiftComboStateType.Active) {
+        var previousType = GiftSendType.fromNumber(previousMessage.getSendType());
+        if (currentType == GiftSendType.Active &&
+                previousType == GiftSendType.Active) {
             giftsMessages.put(userId, currentMessage);
-            return List.of(getGiftComboEvent(currentMessage, GiftComboStateType.Active));
+            return List.of(getGiftComboEvent(currentMessage, GiftSendType.Active));
         }
 
 
-        if (currentType == GiftComboStateType.Finished &&
-                previousType == GiftComboStateType.Active) {
+        if (currentType == GiftSendType.Finished &&
+                previousType == GiftSendType.Active) {
             giftsMessages.clear();
             return List.of(
-                    getGiftComboEvent(currentMessage, GiftComboStateType.Finished),
+                    getGiftComboEvent(currentMessage, GiftSendType.Finished),
                     getGiftEvent(currentMessage));
         }
 
@@ -104,7 +104,7 @@ public class TikTokGiftEventHandler {
         return new TikTokGiftEvent(gift, tikTokRoomInfo.getHost(), message);
     }
 
-    private TikTokGiftEvent getGiftComboEvent(WebcastGiftMessage message, GiftComboStateType state) {
+    private TikTokGiftEvent getGiftComboEvent(WebcastGiftMessage message, GiftSendType state) {
         var gift = getGiftObject(message);
         return new TikTokGiftComboEvent(gift, tikTokRoomInfo.getHost(), message, state);
     }

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

@@ -1,31 +0,0 @@
-package io.github.jwdeveloper.tiktok.websocket;
-
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
-import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
-import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
-import io.github.jwdeveloper.tiktok.live.LiveClient;
-
-public class TikTokWebSocketOfflineClient implements SocketClient {
-
-    private final TikTokLiveEventHandler handler;
-    private LiveClient liveClient;
-
-    public TikTokWebSocketOfflineClient(TikTokLiveEventHandler handler) {
-        this.handler = handler;
-    }
-
-    @Override
-    public void start(LiveConnectionData.Response webcastResponse, LiveClient tikTokLiveClient) {
-        liveClient = tikTokLiveClient;
-        handler.publish(liveClient, new TikTokConnectedEvent());
-    }
-
-    @Override
-    public void stop() {
-        if (liveClient == null) {
-            return;
-        }
-        handler.publish(liveClient, new TikTokDisconnectedEvent());
-    }
-}

Client/src/test/java/io/github/jwdeveloper/tiktok/handlers/events/TikTokGiftEventHandlerTest.java

@@ -27,7 +27,7 @@ import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
-import io.github.jwdeveloper.tiktok.data.models.gifts.GiftComboStateType;
+import io.github.jwdeveloper.tiktok.data.models.gifts.GiftSendType;
 import io.github.jwdeveloper.tiktok.gifts.TikTokGiftsManager;
 import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokGiftEventHandler;
 import io.github.jwdeveloper.tiktok.messages.data.GiftStruct;
@@ -40,6 +40,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
 
 import java.util.List;
+import java.util.logging.Logger;
 
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
@@ -98,9 +99,9 @@ class TikTokGiftEventHandlerTest {
         Assertions.assertEquals(2, result3.size());
         var event3 = (TikTokGiftComboEvent) result3.get(0);
 
-        Assertions.assertEquals(GiftComboStateType.Begin, event1.getComboState());
-        Assertions.assertEquals(GiftComboStateType.Active, event2.getComboState());
-        Assertions.assertEquals(GiftComboStateType.Finished, event3.getComboState());
+        Assertions.assertEquals(GiftSendType.Begin, event1.getComboState());
+        Assertions.assertEquals(GiftSendType.Active, event2.getComboState());
+        Assertions.assertEquals(GiftSendType.Finished, event3.getComboState());
     }
 
 

Examples/pom.xml

@@ -41,7 +41,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.3.0-Release</version>
+        <version>1.3.1-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.3.0-Release</version>
+            <version>1.3.1-Release</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok;
+
+import java.time.Duration;
+
+public class ChatMessageExample {
+    public static void main(String[] args) {
+
+
+        var roomData = TikTokLive.requests()
+                .fetchLiveData("X");
+
+        var gifts = TikTokLive.requests().fetchGiftsData();
+
+
+        var user = TikTokLive.requests()
+                .fetchLiveUserData("mark");
+
+        TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
+                .configure(clientSettings ->
+                {
+                    clientSettings.setPrintToConsole(true);
+                    clientSettings.getHttpSettings().setTimeout(Duration.ofSeconds(21));
+                })
+                .onComment((liveClient, event) ->
+                {
+                    System.out.println("Chat message: " + event.getUser().getName() + " " + event.getText());
+                })
+                .onWebsocketUnhandledMessage((liveClient, event) ->
+                {
+                    liveClient.getLogger().info(event.getMessage().getMethod());
+                }).buildAndConnect();
+    }
+}

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

@@ -39,7 +39,7 @@ public class CustomEventExample {
 
     public static void main(String[] args)
     {
-        TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
+        TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
                 .configure(clientSettings ->
                 {
                     clientSettings.setPrintToConsole(true);

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

@@ -1,67 +0,0 @@
-package io.github.jwdeveloper.tiktok;
-
-import io.github.jwdeveloper.tiktok.data.events.TikTokCommentEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokSubNotifyEvent;
-import io.github.jwdeveloper.tiktok.data.events.TikTokSubscribeEvent;
-import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
-import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokFollowEvent;
-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.gifts.GiftComboStateType;
-import io.github.jwdeveloper.tiktok.live.LiveClient;
-
-public class Events_And_Gifts_Testing_Example {
-    public static void main(String[] args) {
-        LiveClient client = TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
-                .configure(liveClientSettings ->
-                {
-                    liveClientSettings.setOffline(true);
-                    liveClientSettings.setPrintToConsole(true);
-                })
-                .onConnected((liveClient, event) ->
-                {
-                    liveClient.getLogger().info("Connected");
-                })
-                .onDisconnected((liveClient, event) ->
-                {
-                    liveClient.getLogger().info("Disconnected");
-                })
-                .onGiftCombo((liveClient, event) ->
-                {
-                    liveClient.getLogger().info("New fake combo Gift: " + event.getGift());
-                })
-                .onGift((liveClient, event) ->
-                {
-                    liveClient.getLogger().info("New fake Gift: " + event.getGift());
-                })
-                .build();
-
-        var gifts = TikTokLive.gifts();
-        var roseGift = gifts.getByName("Rose");
-
-        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);
-        var fakeJoin = TikTokJoinEvent.of("Mark");
-
-        client.connect();
-
-        client.publishEvent(fakeGift);
-        client.publishEvent(fakeComboGift);
-        client.publishEvent(fakeMessage);
-        client.publishEvent(fakeSubscriber);
-        client.publishEvent(fakeFollow);
-        client.publishEvent(fakeLike);
-        client.publishEvent(fakeJoin);
-
-        client.disconnect();
-    }
-
-
-}

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

@@ -48,7 +48,7 @@ public class ListenerExample
         showLogo();
         CustomListener customListener = new CustomListener();
 
-        TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
+        TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
                 .addListener(customListener)
                 .buildAndConnect();
         System.in.read();

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

@@ -26,7 +26,7 @@ import java.net.Proxy;
 
 public class ProxyExample {
     public static void main(String[] args) throws Exception {
-        TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
+        TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
             .configure(clientSettings -> {
                 clientSettings.setPrintToConsole(true);
                 clientSettings.getHttpSettings().configureProxy(proxySettings -> {

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

@@ -31,7 +31,7 @@ import java.io.IOException;
 import java.time.Duration;
 import java.util.logging.Level;
 
-public class ConnectionExample {
+public class SimpleExample {
     public static String TIKTOK_HOSTNAME = "kvadromama_marina1";
 
     public static void main(String[] args) throws IOException {
@@ -40,10 +40,10 @@ public class ConnectionExample {
 
         var gifts = TikTokLive.gifts();
 
-        TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
+        TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
                 .configure(clientSettings ->
                 {
-                    clientSettings.setHostName(ConnectionExample.TIKTOK_HOSTNAME); // This method is useful in case you want change hostname later
+                    clientSettings.setHostName(SimpleExample.TIKTOK_HOSTNAME); // This method is useful in case you want change hostname later
                     clientSettings.setClientLanguage("en"); // Language
                     clientSettings.setLogLevel(Level.ALL); // Log level
                     clientSettings.setPrintToConsole(true); // Printing all logs to console even if log level is Level.OFF

README.md

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

Tools-EventsCollector/pom.xml

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

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/tester/mockClient/TikTokMockBuilder.java

@@ -86,15 +86,15 @@ public class TikTokMockBuilder extends TikTokLiveClientBuilder {
         var tiktokRoomInfo = new TikTokRoomInfo();
         tiktokRoomInfo.setHostName(clientSettings.getHostName());
 
-        var listenerManager = new TikTokListenersManager(listeners, eventHandler);
+        var listenerManager = new TikTokListenersManager(listeners, tikTokEventHandler);
         var mapper = createMapper(new TikTokGiftsManager(List.of()), tiktokRoomInfo);
-        var handler = new TikTokLiveMessageHandler(eventHandler, mapper);
+        var handler = new TikTokLiveMessageHandler(tikTokEventHandler, mapper);
         var webSocketClient = new WebsocketClientMock(logger, responses, handler);
 
         return new LiveClientMock(tiktokRoomInfo,
                 new TikTokLiveHttpClient(),
                 webSocketClient,
-                eventHandler,
+                tikTokEventHandler,
                 clientSettings,
                 listenerManager,
                 logger);

Tools-EventsWebViewer/pom.xml

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

Tools-ReadmeGenerator/pom.xml

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

extension-collector/pom.xml

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

extension-collector/src/main/java/io/github/jwdeveloper/tiktok/extension/collector/impl/TikTokLiveDataCollector.java

@@ -50,6 +50,7 @@ public class TikTokLiveDataCollector {
         this.settings = settings;
     }
 
+
     public void connectDatabase() {
         var serverApi = ServerApi.builder()
                 .version(ServerApiVersion.V1)

extension-recorder/pom.xml

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

pom.xml

@@ -7,7 +7,7 @@
     <groupId>io.github.jwdeveloper.tiktok</groupId>
     <artifactId>TikTokLiveJava</artifactId>
     <packaging>pom</packaging>
-    <version>1.3.0-Release</version>
+    <version>1.3.1-Release</version>
     <modules>
         <module>API</module>
         <module>Client</module>