Changes:

- Fixed bug: library was not working on certain java versions
   due to different WebSocket implementation. Instead of using java websocket api now there is `org.java-websocket`

.github/workflows/maven-publish.yml

@@ -32,13 +32,10 @@ jobs:
           change_path: "."
           short_tags: false
           bump_each_commit: false
-
        
    
     - name: 2.7 Update version in pom.xml (Release only)
       run: mvn versions:set -DnewVersion=${{steps.version.outputs.version_tag}} 
-    - name: 2.8 Update modules parent version
-      run: mvn versions:update-child-modules
            
     - name: 3 Build with Maven
       run: mvn package -P publish --file pom.xml  
@@ -76,6 +73,10 @@ jobs:
             git config --local user.email "action@github.com"
             git config --local user.name "GitHub Action"
             git add pom.xml
+            git add API/pom.xml
+            git add Client/pom.xml
+            git add TestApplication/pom.xml
+            git add Tools/pom.xml
             git commit -m "Update version in pom.xml"
     - name: Push changes
       uses: ad-m/github-push-action@master

API/pom.xml

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

API/src/main/java/io/github/jwdeveloper/tiktok/ClientSettings.java

@@ -3,6 +3,8 @@ package io.github.jwdeveloper.tiktok;
 import lombok.Data;
 
 import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.logging.Level;
 
 @Data
@@ -10,62 +12,58 @@ public class ClientSettings {
     /// <summary>
     /// Timeout for Connections
     /// </summary>
-
-    private Duration Timeout;
-    /// <summary>
-    /// Polling-Interval for Socket-Connection
-    /// </summary
-
-    private Duration PollingInterval;
-    /// <summary>
-    /// Proxy for Connection
-    /// </summary>
+    private Duration timeout;
 
     // public RotatingProxy Proxy;
     /// <summary>
     /// ISO-Language for Client
     /// </summary>
 
-    private String ClientLanguage;
-    /// <summary>
-    /// Size for Buffer for Socket-Connection
-    /// </summary>
-
-    private int SocketBufferSize;
+    private String clientLanguage;
 
     /// <summary>
     /// Whether to Retry if Connection Fails
     /// </summary>
-    private boolean RetryOnConnectionFailure;
+    private boolean retryOnConnectionFailure;
 
+    /// <summary>
+    /// Wait to connect again for selected amount of time
+    /// </summary>
+    private Duration retryConnectionTimeout;
 
     /// <summary>
     /// Whether to handle Messages received from Room when Connecting
     /// </summary>
-    private boolean HandleExistingMessagesOnConnect;
+    private boolean handleExistingMessagesOnConnect;
     /// <summary>
     /// Whether to download List of Gifts for Room when Connecting
     /// </summary>
-    private boolean DownloadGiftInfo;
+    private boolean downloadGiftInfo;
 
     /// <summary>
     /// Whether to print Logs to Console
     /// </summary>
 
-    private boolean PrintToConsole;
+    private boolean printToConsole;
     /// <summary>
     /// LoggingLevel for Logs
     /// </summary>
-    private Level LogLevel;
+    private Level logLevel;
 
     /// <summary>
     /// Whether to print Base64-Data for Messages to Console
     /// </summary>
-    private boolean PrintMessageData;
+    private boolean printMessageData;
 
     /// <summary>
-    /// Whether to check Messages for Unparsed Data
+    /// Tiktok user name
     /// </summary>
-    private boolean CheckForUnparsedData;
+    private String hostName;
+
+
+    /// <summary>
+    /// Parameters used in requests to tiktok api
+    /// </summary>
+    private Map<String, Object> clientParameters;
 }
 

API/src/main/java/io/github/jwdeveloper/tiktok/Constants.java

@@ -39,18 +39,16 @@ public class Constants {
 
     public static ClientSettings DefaultClientSettings() {
         var clientSettings = new ClientSettings();
-
         clientSettings.setTimeout(Duration.ofSeconds(DEFAULT_TIMEOUT));
-        clientSettings.setPollingInterval(Duration.ofSeconds(DEFAULT_POLLTIME));
         clientSettings.setClientLanguage("en-US");
         clientSettings.setHandleExistingMessagesOnConnect(true);
         clientSettings.setDownloadGiftInfo(true);
-        clientSettings.setRetryOnConnectionFailure(true);
-        clientSettings.setSocketBufferSize(500_000);
-        clientSettings.setPrintToConsole(true);
+        clientSettings.setRetryOnConnectionFailure(false);
+        clientSettings.setRetryConnectionTimeout(Duration.ofSeconds(1));
+        clientSettings.setPrintToConsole(false);
         clientSettings.setLogLevel(Level.ALL);
-        clientSettings.setCheckForUnparsedData(false);
         clientSettings.setPrintMessageData(false);
+        clientSettings.setClientParameters(Constants.DefaultClientParams());
         return clientSettings;
     }
 

API/src/main/java/io/github/jwdeveloper/tiktok/events/TikTokEventBuilder.java

@@ -1,95 +1,94 @@
 package io.github.jwdeveloper.tiktok.events;
 
 import io.github.jwdeveloper.tiktok.events.messages.*;
-
 import java.util.function.Consumer;
 
 
 
 public interface TikTokEventBuilder<T> {
-    T onUnhandledSocial(Consumer<TikTokUnhandledSocialEvent> event);
+    T onUnhandledSocial(TikTokEventConsumer<TikTokUnhandledSocialEvent> event);
 
-    T onLinkMicFanTicket(Consumer<TikTokLinkMicFanTicketEvent> event);
+    T onLinkMicFanTicket(TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event);
 
-    T onEnvelope(Consumer<TikTokEnvelopeEvent> event);
+    T onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event);
 
-    T onShopMessage(Consumer<TikTokShopMessageEvent> event);
+    T onShopMessage(TikTokEventConsumer<TikTokShopMessageEvent> event);
 
-    T onDetectMessage(Consumer<TikTokDetectMessageEvent> event);
+    T onDetectMessage(TikTokEventConsumer<TikTokDetectMessageEvent> event);
 
-    T onLinkLayerMessage(Consumer<TikTokLinkLayerMessageEvent> event);
+    T onLinkLayerMessage(TikTokEventConsumer<TikTokLinkLayerMessageEvent> event);
 
-    T onConnected(Consumer<TikTokConnectedEvent> event);
+    T onConnected(TikTokEventConsumer<TikTokConnectedEvent> event);
 
-    T onCaption(Consumer<TikTokCaptionEvent> event);
+    T onCaption(TikTokEventConsumer<TikTokCaptionEvent> event);
 
-    T onQuestion(Consumer<TikTokQuestionEvent> event);
+    T onQuestion(TikTokEventConsumer<TikTokQuestionEvent> event);
 
-    T onRoomPinMessage(Consumer<TikTokRoomPinMessageEvent> event);
+    T onRoomPinMessage(TikTokEventConsumer<TikTokRoomPinMessageEvent> event);
 
-    T onRoomMessage(Consumer<TikTokRoomMessageEvent> event);
+    T onRoomMessage(TikTokEventConsumer<TikTokRoomMessageEvent> event);
 
-    T onLivePaused(Consumer<TikTokLivePausedEvent> event);
+    T onLivePaused(TikTokEventConsumer<TikTokLivePausedEvent> event);
 
-    T onLike(Consumer<TikTokLikeEvent> event);
+    T onLike(TikTokEventConsumer<TikTokLikeEvent> event);
 
-    T onLinkMessage(Consumer<TikTokLinkMessageEvent> event);
+    T onLinkMessage(TikTokEventConsumer<TikTokLinkMessageEvent> event);
 
-    T onBarrageMessage(Consumer<TikTokBarrageMessageEvent> event);
+    T onBarrageMessage(TikTokEventConsumer<TikTokBarrageMessageEvent> event);
 
-    T onGiftMessage(Consumer<TikTokGiftMessageEvent> event);
+    T onGiftMessage(TikTokEventConsumer<TikTokGiftMessageEvent> event);
 
-    T onLinkMicArmies(Consumer<TikTokLinkMicArmiesEvent> event);
+    T onLinkMicArmies(TikTokEventConsumer<TikTokLinkMicArmiesEvent> event);
 
-    T onEmote(Consumer<TikTokEmoteEvent> event);
+    T onEmote(TikTokEventConsumer<TikTokEmoteEvent> event);
 
-    T onUnauthorizedMember(Consumer<TikTokUnauthorizedMemberEvent> event);
+    T onUnauthorizedMember(TikTokEventConsumer<TikTokUnauthorizedMemberEvent> event);
 
-    T onInRoomBanner(Consumer<TikTokInRoomBannerEvent> event);
+    T onInRoomBanner(TikTokEventConsumer<TikTokInRoomBannerEvent> event);
 
-    T onLinkMicMethod(Consumer<TikTokLinkMicMethodEvent> event);
+    T onLinkMicMethod(TikTokEventConsumer<TikTokLinkMicMethodEvent> event);
 
-    T onSubscribe(Consumer<TikTokSubscribeEvent> event);
+    T onSubscribe(TikTokEventConsumer<TikTokSubscribeEvent> event);
 
-    T onPollMessage(Consumer<TikTokPollMessageEvent> event);
+    T onPollMessage(TikTokEventConsumer<TikTokPollMessageEvent> event);
 
-    T onFollow(Consumer<TikTokFollowEvent> event);
+    T onFollow(TikTokEventConsumer<TikTokFollowEvent> event);
 
-    T onRoomViewerData(Consumer<TikTokRoomViewerDataEvent> event);
+    T onRoomViewerData(TikTokEventConsumer<TikTokRoomViewerDataEvent> event);
 
-    T onGoalUpdate(Consumer<TikTokGoalUpdateEvent> event);
+    T onGoalUpdate(TikTokEventConsumer<TikTokGoalUpdateEvent> event);
 
-    T onComment(Consumer<TikTokCommentEvent> event);
+    T onComment(TikTokEventConsumer<TikTokCommentEvent> event);
 
-    T onRankUpdate(Consumer<TikTokRankUpdateEvent> event);
+    T onRankUpdate(TikTokEventConsumer<TikTokRankUpdateEvent> event);
 
-    T onIMDelete(Consumer<TikTokIMDeleteEvent> event);
+    T onIMDelete(TikTokEventConsumer<TikTokIMDeleteEvent> event);
 
-    T onLiveEnded(Consumer<TikTokLiveEndedEvent> event);
+    T onLiveEnded(TikTokEventConsumer<TikTokLiveEndedEvent> event);
 
-    T onError(Consumer<TikTokErrorEvent> event);
+    T onError(TikTokEventConsumer<TikTokErrorEvent> event);
 
-    T onUnhandled(Consumer<TikTokUnhandledEvent> event);
+    T onUnhandled(TikTokEventConsumer<TikTokUnhandledEvent> event);
 
-    T onJoin(Consumer<TikTokJoinEvent> event);
+    T onJoin(TikTokEventConsumer<TikTokJoinEvent> event);
 
-    T onRankText(Consumer<TikTokRankTextEvent> event);
+    T onRankText(TikTokEventConsumer<TikTokRankTextEvent> event);
 
-    T onShare(Consumer<TikTokShareEvent> event);
+    T onShare(TikTokEventConsumer<TikTokShareEvent> event);
 
-    T onUnhandledMember(Consumer<TikTokUnhandledMemberEvent> event);
+    T onUnhandledMember(TikTokEventConsumer<TikTokUnhandledMemberEvent> event);
 
-    T onSubNotify(Consumer<TikTokSubNotifyEvent> event);
+    T onSubNotify(TikTokEventConsumer<TikTokSubNotifyEvent> event);
 
-    T onLinkMicBattle(Consumer<TikTokLinkMicBattleEvent> event);
+    T onLinkMicBattle(TikTokEventConsumer<TikTokLinkMicBattleEvent> event);
 
-    T onDisconnected(Consumer<TikTokDisconnectedEvent> event);
+    T onDisconnected(TikTokEventConsumer<TikTokDisconnectedEvent> event);
 
-    T onGiftBroadcast(Consumer<TikTokGiftBroadcastEvent> event);
+    T onGiftBroadcast(TikTokEventConsumer<TikTokGiftBroadcastEvent> event);
 
-    T onUnhandledControl(Consumer<TikTokUnhandledControlEvent> event);
+    T onUnhandledControl(TikTokEventConsumer<TikTokUnhandledControlEvent> event);
 
-    T onEvent(Consumer<TikTokEvent> event);
+    T onEvent(TikTokEventConsumer<TikTokEvent> event);
 }
 
 

API/src/main/java/io/github/jwdeveloper/tiktok/events/TikTokEventConsumer.java

@@ -2,7 +2,7 @@ package io.github.jwdeveloper.tiktok.events;
 
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 
-public interface TikTokLiveEvent<T extends TikTokEvent>
+public interface TikTokEventConsumer<T extends TikTokEvent>
 {
      void onEvent(LiveClient liveClient, T event);
 }

API/src/main/java/io/github/jwdeveloper/tiktok/events/messages/TikTokGiftMessageEvent.java

@@ -3,38 +3,39 @@ package io.github.jwdeveloper.tiktok.events.messages;
 import io.github.jwdeveloper.tiktok.annotations.Nullable;
 import io.github.jwdeveloper.tiktok.events.TikTokEvent;
 import io.github.jwdeveloper.tiktok.events.objects.Gift;
+import io.github.jwdeveloper.tiktok.events.objects.TikTokGift;
 import io.github.jwdeveloper.tiktok.events.objects.User;
 import io.github.jwdeveloper.tiktok.messages.WebcastGiftMessage;
 import lombok.Getter;
 
 @Getter
 public class TikTokGiftMessageEvent extends TikTokEvent {
-  private final Gift gift;
 
-  @Nullable
-  private User sender;
+    private final Gift gift;
 
-  private final String purchaseId;
+    @Nullable
+    private User sender;
 
-  private final String receipt;
+    private final String purchaseId;
 
-  private final Integer amount;
+    private final String receipt;
 
-  private final  Boolean streakFinished;
+    private final Integer amount;
 
-  private final Integer streakIndex;
+    private final Boolean streakFinished;
 
-  public TikTokGiftMessageEvent(WebcastGiftMessage msg) {
-    super(msg.getHeader());;
-    gift = new Gift(msg.getGiftDetails());
-    if(msg.hasSender())
-    {
-      sender = new User(msg.getSender());
+    private final Integer streakIndex;
+
+    public TikTokGiftMessageEvent(WebcastGiftMessage msg) {
+        super(msg.getHeader());
+        gift = new Gift(msg.getGiftDetails());
+        if (msg.hasSender()) {
+            sender = new User(msg.getSender());
+        }
+        purchaseId = msg.getLogId();
+        receipt = msg.getReceiptJson();
+        amount = msg.getAmount();
+        streakFinished = msg.getRepeatEnd();
+        streakIndex = msg.getRepeatCount();
     }
-    purchaseId = msg.getLogId();
-    receipt = msg.getReceiptJson();
-    amount = msg.getAmount();
-    streakFinished = msg.getRepeatEnd();
-    streakIndex = msg.getRepeatCount();
-  }
 }

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

@@ -6,12 +6,10 @@ import lombok.Getter;
 
 @Getter
 public class TikTokIMDeleteEvent extends TikTokEvent {
-  private final String data1;
-  private final String data2;
+    private final byte[] data;
 
-  public TikTokIMDeleteEvent(WebcastImDeleteMessage msg) {
-    super(msg.getHeader());;
-    data1 = msg.getData1();
-    data2 = msg.getData2();
-  }
+    public TikTokIMDeleteEvent(WebcastImDeleteMessage msg) {
+        super(msg.getHeader());
+        data = msg.getData().toByteArray();
+    }
 }

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

@@ -20,10 +20,15 @@ public class TikTokRankUpdateEvent extends TikTokEvent {
     var rankData = msg.getData().getRankings();
     eventType = rankData.getType();
     label = rankData.getLabel();
-    rank = rankData.getDetails(0).getLabel();
+    if(rankData.getDetailsList().isEmpty())
+    {
+      rank = "";
+    }
+    else
+    {
+      rank = rankData.getDetails(0).getLabel();
+    }
     color = rankData.getColor().getColor();
-
-
   }
 
   public TikTokRankUpdateEvent(WebcastRankUpdateMessage msg) {
@@ -31,7 +36,14 @@ public class TikTokRankUpdateEvent extends TikTokEvent {
     var rankData = msg.getData().getRankData();
     eventType = rankData.getType();
     label = rankData.getLabel();
-    rank = rankData.getDetails(0).getLabel();
+    if(rankData.getDetailsList().isEmpty())
+    {
+      rank = "";
+    }
+    else
+    {
+      rank = rankData.getDetails(0).getLabel();
+    }
     color = rankData.getColor().getColor();
   }
 

API/src/main/java/io/github/jwdeveloper/tiktok/events/objects/Badge.java

@@ -7,14 +7,14 @@ import java.util.List;
 
 @Getter
 public class Badge {
-    private final ComboBadge comboBadges;
+    private  ComboBadge comboBadges;
     private final List<TextBadge> textBadges;
     private final List<ImageBadge> imageBadges;
 
     public Badge(io.github.jwdeveloper.tiktok.messages.Badge badge) {
         textBadges = badge.getTextBadgesList().stream().map(b -> new TextBadge(b.getType(), b.getName())).toList();
         imageBadges = badge.getImageBadgesList().stream().map(b -> new ImageBadge(b.getDisplayType(), new Picture(b.getImage()))).toList();
-        comboBadges = new ComboBadge(new Picture(badge.getComplexBadge().getImageUrl()), badge.getComplexBadge().getData());
+        comboBadges = new ComboBadge(new Picture("badge.getComplexBadge().getImageUrl()"), badge.getComplexBadge().getData());
     }
 
 

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokLiveMessageException.java

@@ -0,0 +1,33 @@
+package io.github.jwdeveloper.tiktok.exceptions;
+
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+import lombok.Getter;
+
+import java.util.Base64;
+
+public class TikTokLiveMessageException extends TikTokLiveException {
+
+    @Getter
+    private final WebcastResponse.Message webcastMessage;
+    @Getter
+    private final WebcastResponse webcastResponse;
+
+
+    public TikTokLiveMessageException(WebcastResponse.Message message,
+                                      WebcastResponse webcastResponse,
+                                      Throwable cause) {
+        super("Error while handling Message: " + message.getType() + ": \n", cause);
+        this.webcastMessage = message;
+        this.webcastResponse = webcastResponse;
+    }
+
+    public void messageToBase64()
+    {
+        var decoded = Base64.getEncoder().encodeToString(webcastMessage.getBinary().toByteArray());
+    }
+
+    public void webcastResponseToBase64()
+    {
+        var decoded = Base64.getEncoder().encodeToString(webcastResponse.toByteArray());
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokLiveMessageParsingException.java

@@ -1,23 +0,0 @@
-package io.github.jwdeveloper.tiktok.exceptions;
-
-public class TikTokLiveMessageParsingException extends TikTokLiveException
-{
-    public TikTokLiveMessageParsingException() {
-    }
-
-    public TikTokLiveMessageParsingException(String message) {
-        super(message);
-    }
-
-    public TikTokLiveMessageParsingException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    public TikTokLiveMessageParsingException(Throwable cause) {
-        super(cause);
-    }
-
-    public TikTokLiveMessageParsingException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
-        super(message, cause, enableSuppression, writableStackTrace);
-    }
-}

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokLiveOfflineHostException.java

@@ -0,0 +1,8 @@
+package io.github.jwdeveloper.tiktok.exceptions;
+
+public class TikTokLiveOfflineHostException extends TikTokLiveException
+{
+    public TikTokLiveOfflineHostException(String message) {
+        super(message);
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokLiveRequestException.java

@@ -0,0 +1,23 @@
+package io.github.jwdeveloper.tiktok.exceptions;
+
+public class TikTokLiveRequestException extends TikTokLiveException
+{
+    public TikTokLiveRequestException() {
+    }
+
+    public TikTokLiveRequestException(String message) {
+        super(message);
+    }
+
+    public TikTokLiveRequestException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TikTokLiveRequestException(Throwable cause) {
+        super(cause);
+    }
+
+    public TikTokLiveRequestException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokMessageMappingException.java

@@ -0,0 +1,15 @@
+package io.github.jwdeveloper.tiktok.exceptions;
+
+
+public class TikTokMessageMappingException extends TikTokLiveException
+{
+    public TikTokMessageMappingException(Class<?> inputClazz, Class<?> outputClass, Throwable throwable)
+    {
+        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + " to class " + outputClass.getSimpleName(),throwable);
+    }
+
+    public TikTokMessageMappingException(Class<?> inputClazz, Class<?> outputClass, String message)
+    {
+        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + " to class " + outputClass.getSimpleName()+": "+message);
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/exceptions/TikTokProtocolBufferException.java

@@ -0,0 +1,15 @@
+package io.github.jwdeveloper.tiktok.exceptions;
+
+import lombok.Getter;
+
+public class TikTokProtocolBufferException extends TikTokLiveException
+{
+    @Getter
+    private final byte[] bytes;
+
+    public TikTokProtocolBufferException(String message, byte[] bytes, Throwable cause)
+    {
+        super(message, cause);
+        this.bytes = bytes;
+    }
+}

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

@@ -0,0 +1,10 @@
+package io.github.jwdeveloper.tiktok.handler;
+
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+
+public interface TikTokMessageHandler
+{
+    TikTokEvent handle(WebcastResponse.Message message) throws Exception;
+}

API/src/main/java/io/github/jwdeveloper/tiktok/http/Resource/ClientFetchDataResponse.java

@@ -1,7 +0,0 @@
-package io.github.jwdeveloper.tiktok.http.Resource;
-
-import lombok.Data;
-
-@Data
-public class ClientFetchDataResponse {
-}

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

@@ -0,0 +1,14 @@
+package io.github.jwdeveloper.tiktok.live;
+
+import io.github.jwdeveloper.tiktok.events.objects.TikTokGift;
+import io.github.jwdeveloper.tiktok.models.GiftId;
+import io.github.jwdeveloper.tiktok.models.gifts.TikTokGiftInfo;
+
+import java.util.Map;
+
+public interface GiftManager
+{
+     Map<Integer, TikTokGiftInfo> getGiftsInfo();
+
+     Map<GiftId, TikTokGift> getActiveGifts();
+}

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

@@ -6,5 +6,6 @@ public interface LiveClient {
 
     void disconnect();
 
+    GiftManager getGiftManager();
     LiveRoomInfo getRoomInfo();
 }

API/src/main/java/io/github/jwdeveloper/tiktok/models/GiftId.java

@@ -7,7 +7,7 @@ import lombok.Data;
 @AllArgsConstructor
 public class GiftId
 {
-    public long Gift;
+    private long giftId;
 
-    public String UserName;
+    private String userName;
 }

API/src/main/java/io/github/jwdeveloper/tiktok/models/GiftStrike.java

@@ -0,0 +1,6 @@
+package io.github.jwdeveloper.tiktok.models;
+
+public enum GiftStrike
+{
+    BEGIN, UPDATE, ENDED
+}

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

@@ -3,14 +3,13 @@ package io.github.jwdeveloper.tiktok.models.gifts;
 import lombok.Data;
 
 @Data
-public class DefaultFormat
-{
-    private boolean bold ;
-    private String color ;
-    private int font_size ;
-    private boolean italic ;
-    private int italic_angle ;
-    private boolean use_highlight_color ;
-    private boolean use_remote_color ;
-    private int weight ;
+public class DefaultFormat {
+    private boolean bold;
+    private String color;
+    private int font_size;
+    private boolean italic;
+    private int italic_angle;
+    private boolean use_highlight_color;
+    private boolean use_remote_color;
+    private int weight;
 }

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

@@ -5,10 +5,9 @@ import lombok.Data;
 import java.util.List;
 
 @Data
-public class DisplayText
-{
-    private DefaultFormat default_format ;
-    private String default_pattern ;
-    private String key ;
-    private List<Object> pieces ;
+public class DisplayText {
+    private DefaultFormat default_format;
+    private String default_pattern;
+    private String key;
+    private List<Object> pieces;
 }

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

@@ -5,14 +5,13 @@ import lombok.Data;
 import java.util.List;
 
 @Data
-public class GiftLabelIcon
-{
-    private String avg_color ;
-    private int height ;
-    private int image_type ;
-    private boolean is_animated ;
-    private String open_web_url ;
-    private String uri ;
-    private List<String> url_list ;
-    private int width ;
+public class GiftLabelIcon {
+    private String avg_color;
+    private int height;
+    private int image_type;
+    private boolean is_animated;
+    private String open_web_url;
+    private String uri;
+    private List<String> url_list;
+    private int width;
 }

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

@@ -6,10 +6,9 @@ import java.util.List;
 
 
 @Data
-public class GiftPanelBanner
-{
-    private List<Object> bg_color_values ;
-    private DisplayText display_text ;
-    private LeftIcon left_icon ;
-    private String schema_url ;
+public class GiftPanelBanner {
+    private List<Object> bg_color_values;
+    private DisplayText display_text;
+    private LeftIcon left_icon;
+    private String schema_url;
 }

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

@@ -5,14 +5,13 @@ import lombok.Data;
 import java.util.List;
 
 @Data
-public class Image
-{
-    private String avg_color ;
-    private int height ;
-    private int image_type ;
-    private boolean is_animated ;
-    private String open_web_url ;
-    private String uri ;
-    private List<String> url_list ;
-    private int width ;
+public class Image {
+    private String avg_color;
+    private int height;
+    private int image_type;
+    private boolean is_animated;
+    private String open_web_url;
+    private String uri;
+    private List<String> url_list;
+    private int width;
 }

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

@@ -5,16 +5,15 @@ import lombok.Data;
 import java.util.List;
 
 @Data
-public class LeftIcon
-{
-    private String avg_color ;
-    private int height ;
-    private int image_type ;
-    private boolean is_animated ;
-    private String open_web_url ;
-    private String uri ;
-    private List<String> url_list ;
-    private int width ;
+public class LeftIcon {
+    private String avg_color;
+    private int height;
+    private int image_type;
+    private boolean is_animated;
+    private String open_web_url;
+    private String uri;
+    private List<String> url_list;
+    private int width;
 }
 
 

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

@@ -1,6 +1,9 @@
 package io.github.jwdeveloper.tiktok.models.gifts;
 
+import lombok.Data;
+
+@Data
 public class LockInfo
 {
-    public int lock_type;
+    private int lock_type;
 }

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

@@ -5,7 +5,7 @@ import lombok.Data;
 import java.util.List;
 
 @Data
-public class TikTokGift
+public class TikTokGiftInfo
 {
     private int action_type;
     private int app_id;

API/src/main/proto/tiktokSchema.proto

@@ -186,7 +186,7 @@ message Badge {
 
   message BadgeComplex {
     uint32 data1 = 1;
-    string imageUrl = 2;
+    //string imageUrl = 2; Protocol message had invalid UTF-8
     string data = 4;
     DataContainer detail1 = 5;
     string data2 = 6;
@@ -377,7 +377,7 @@ message RankTextMessage {
 // Links to Image-Files on the TikTok CDN
 message Picture {
   repeated string urls = 1; // Usually has 3 different urls with different sizes/extensions
-  string prefix = 2; // uri
+ // string prefix = 2; // uri not working
   uint32 data1 = 3;
   uint32 data2 = 4;
   string color = 5;
@@ -681,7 +681,7 @@ message WebcastGiftMessage {
   uint32 data11 = 34;
 
   message GiftData1 {
-    string data1 = 1;
+   // string data1 = 1; not working
     uint32 data2 = 2;
     uint32 data3 = 3;
   }
@@ -749,8 +749,7 @@ message WebcastHourlyRankMessage {
 // Message related to Chat-moderation?
 message WebcastImDeleteMessage {
   MessageHeader header = 1;
-  string data1 = 2;
-  string data2 = 3;
+  bytes data = 3;
 }
 
 message WebcastInRoomBannerMessage {

Client/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>1.0.0</version>
+        <version>0.0.12-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -29,6 +29,23 @@
             <artifactId>protobuf-java</artifactId>
             <version>3.24.1</version>
         </dependency>
+
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>2.0.7</version>
+        </dependency>
+        <dependency>
+            <groupId>org.java-websocket</groupId>
+            <artifactId>Java-WebSocket</artifactId>
+            <version>1.5.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>2.0.7</version>
+            <scope>runtime</scope>
+        </dependency>
     </dependencies>
 
 

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

@@ -1,45 +1,47 @@
 package io.github.jwdeveloper.tiktok;
 
 import io.github.jwdeveloper.tiktok.events.objects.TikTokGift;
-import io.github.jwdeveloper.tiktok.http.TikTokApiService;
+import io.github.jwdeveloper.tiktok.live.GiftManager;
+import io.github.jwdeveloper.tiktok.messages.WebcastGiftMessage;
 import io.github.jwdeveloper.tiktok.models.GiftId;
-
+import io.github.jwdeveloper.tiktok.models.gifts.TikTokGiftInfo;
 import lombok.Getter;
 
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.logging.Logger;
 
-public class TikTokGiftManager {
-    private Logger logger;
-    private ClientSettings clientSettings;
-    private TikTokApiService apiService;
-    private Map<Integer, TikTokGift> gifts;
+public class TikTokGiftManager implements GiftManager {
 
     @Getter
-    private Map<GiftId, TikTokGift> activeGifts;
+    private final Map<Integer, TikTokGiftInfo> giftsInfo;
+    @Getter
+    private final Map<GiftId, TikTokGift> activeGifts;
 
-    public TikTokGiftManager(Logger logger, TikTokApiService apiService, ClientSettings clientSettings) {
-        this.logger = logger;
-        this.clientSettings = clientSettings;
-        this.apiService = apiService;
-        this.gifts = new HashMap<>();
+    public TikTokGiftManager() {
+        giftsInfo = new HashMap<>();
         activeGifts = new HashMap<>();
     }
 
-    public void loadGifts() {
-        if (!clientSettings.isDownloadGiftInfo()) {
-            return;
+    public TikTokGift updateActiveGift(WebcastGiftMessage giftMessage) {
+        var giftId = new GiftId(giftMessage.getGiftId(), giftMessage.getSender().getUniqueId());
+        if (activeGifts.containsKey(giftId)) {
+            var gift = activeGifts.get(giftId);
+            gift.setAmount(giftMessage.getAmount());
+        } else {
+            var newGift = new TikTokGift(giftMessage);
+            activeGifts.put(giftId, newGift);
         }
-        logger.info("Fetching gifts");
-        //TODO gifts =apiService.fetchAvailableGifts();
+
+        var gift = activeGifts.get(giftId);
+
+        if (giftMessage.getRepeatEnd()) {
+            gift.setStreakFinished(true);
+            activeGifts.remove(giftId);
+        }
+        return gift;
     }
 
-    public List<TikTokGift> getGifts()
-    {
-        return gifts.values().stream().toList();
+    public void loadGifsInfo(Map<Integer, TikTokGiftInfo> gifts) {
+        this.giftsInfo.putAll(gifts);
     }
-
-
 }

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

@@ -8,6 +8,4 @@ public class TikTokLive
     {
         return new TikTokLiveClientBuilder(userName);
     }
-
-
 }

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

@@ -1,53 +1,70 @@
 package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.tiktok.events.messages.TikTokDisconnectedEvent;
+import io.github.jwdeveloper.tiktok.events.messages.TikTokErrorEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveOfflineHostException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventHandler;
 import io.github.jwdeveloper.tiktok.http.TikTokApiService;
 import io.github.jwdeveloper.tiktok.live.ConnectionState;
+import io.github.jwdeveloper.tiktok.live.GiftManager;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
-import io.github.jwdeveloper.tiktok.live.TikTokRoomInfo;
-import io.github.jwdeveloper.tiktok.websocket.TikTokWebsocketClient;
+import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;
 
 import java.util.logging.Logger;
 
 public class TikTokLiveClient implements LiveClient {
-    private final TikTokRoomInfo meta;
-    private final TikTokGiftManager giftManager;
+    private final TikTokRoomInfo liveRoomInfo;
+    private final TikTokGiftManager tikTokGiftManager;
     private final TikTokApiService apiClient;
-    private final TikTokWebsocketClient webSocketClient;
+    private final TikTokWebSocketClient webSocketClient;
     private final TikTokEventHandler tikTokEventHandler;
+    private final ClientSettings clientSettings;
     private final Logger logger;
 
-
     public TikTokLiveClient(TikTokRoomInfo tikTokLiveMeta,
                             TikTokApiService tikTokApiService,
-                            TikTokWebsocketClient webSocketClient,
+                            TikTokWebSocketClient webSocketClient,
                             TikTokGiftManager tikTokGiftManager,
                             TikTokEventHandler tikTokEventHandler,
+                            ClientSettings clientSettings,
                             Logger logger) {
-        this.meta = tikTokLiveMeta;
-        this.giftManager = tikTokGiftManager;
+        this.liveRoomInfo = tikTokLiveMeta;
+        this.tikTokGiftManager = tikTokGiftManager;
         this.apiClient = tikTokApiService;
         this.webSocketClient = webSocketClient;
-        this.logger = logger;
         this.tikTokEventHandler = tikTokEventHandler;
+        this.clientSettings = clientSettings;
+        this.logger = logger;
     }
 
 
-
-
     public void connect() {
         try {
             tryConnect();
-        } catch (Exception e) {
-            e.printStackTrace();
+        }
+        catch (TikTokLiveException e)
+        {
             setState(ConnectionState.DISCONNECTED);
+            tikTokEventHandler.publish(this, new TikTokErrorEvent(e));
+            tikTokEventHandler.publish(this, new TikTokDisconnectedEvent());
+
+            if(e instanceof TikTokLiveOfflineHostException && clientSettings.isRetryOnConnectionFailure())
+            {
+                try {
+                    Thread.sleep(clientSettings.getRetryConnectionTimeout().toMillis());
+                }
+                catch (Exception ignored){}
+                logger.info("Reconnecting");
+                this.connect();
+            }
+            throw e;
         }
     }
 
     public void disconnect() {
-        if (!meta.hasConnectionState(ConnectionState.CONNECTED)) {
+        if (!liveRoomInfo.hasConnectionState(ConnectionState.CONNECTED)) {
             return;
         }
         webSocketClient.stop();
@@ -55,40 +72,48 @@ public class TikTokLiveClient implements LiveClient {
     }
 
 
+
     public void tryConnect() {
-        if (meta.hasConnectionState(ConnectionState.CONNECTED))
-            throw new RuntimeException("Already connected");
-        if (meta.hasConnectionState(ConnectionState.CONNECTING))
-            throw new RuntimeException("Already connecting");
+        if (liveRoomInfo.hasConnectionState(ConnectionState.CONNECTED))
+            throw new TikTokLiveException("Already connected");
+        if (liveRoomInfo.hasConnectionState(ConnectionState.CONNECTING))
+            throw new TikTokLiveException("Already connecting");
 
         logger.info("Connecting");
         setState(ConnectionState.CONNECTING);
 
-        var roomId = apiClient.fetchRoomId(meta.getUserName());
-        meta.setRoomId(roomId);
-        var roomData =apiClient.fetchRoomInfo();
-        if (roomData.getStatus() == 0 || roomData.getStatus() == 4)
-        {
-            throw new TikTokLiveException("LiveStream for HostID could not be found. Is the Host online?");
+        var roomId = apiClient.fetchRoomId(liveRoomInfo.getUserName());
+        liveRoomInfo.setRoomId(roomId);
+        var roomData = apiClient.fetchRoomInfo();
+        if (roomData.getStatus() == 0 || roomData.getStatus() == 4) {
+            throw new TikTokLiveOfflineHostException("LiveStream for HostID could not be found. Is the Host online?");
         }
 
-       // giftManager.loadGifts();
+        if (clientSettings.isDownloadGiftInfo())
+        {
+            logger.info("Fetch Gift info");
+            var gifts = apiClient.fetchAvailableGifts();
+            tikTokGiftManager.loadGifsInfo(gifts);
+        }
         var clientData = apiClient.fetchClientData();
-        webSocketClient.start(clientData);
+        webSocketClient.start(clientData, this);
         setState(ConnectionState.CONNECTED);
     }
 
 
-
-
     public LiveRoomInfo getRoomInfo() {
-        return meta;
+        return liveRoomInfo;
+    }
+
+    @Override
+    public GiftManager getGiftManager() {
+        return tikTokGiftManager;
     }
 
 
     private void setState(ConnectionState connectionState) {
         logger.info("TikTokLive client state: " + connectionState.name());
-        meta.setConnectionState(connectionState);
+        liveRoomInfo.setConnectionState(connectionState);
     }
 
 

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

@@ -2,114 +2,87 @@ package io.github.jwdeveloper.tiktok;
 
 import io.github.jwdeveloper.tiktok.events.TikTokEvent;
 import io.github.jwdeveloper.tiktok.events.TikTokEventBuilder;
-import io.github.jwdeveloper.tiktok.handlers.TikTokEventHandler;
+import io.github.jwdeveloper.tiktok.events.TikTokEventConsumer;
 import io.github.jwdeveloper.tiktok.events.messages.*;
-import io.github.jwdeveloper.tiktok.handlers.WebResponseHandler;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.handlers.TikTokEventHandler;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
 import io.github.jwdeveloper.tiktok.http.TikTokApiService;
 import io.github.jwdeveloper.tiktok.http.TikTokCookieJar;
 import io.github.jwdeveloper.tiktok.http.TikTokHttpApiClient;
 import io.github.jwdeveloper.tiktok.http.TikTokHttpRequestFactory;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.live.TikTokRoomInfo;
-import io.github.jwdeveloper.tiktok.websocket.TikTokWebsocketClient;
+import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;
 
 import java.time.Duration;
-import java.util.Map;
 import java.util.function.Consumer;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveClientBuilder> {
-    private String userName;
     private final ClientSettings clientSettings;
-    private Map<String, Object> clientParameters;
     private final Logger logger;
     private final TikTokEventHandler tikTokEventHandler;
 
     public TikTokLiveClientBuilder(String userName) {
         this.tikTokEventHandler = new TikTokEventHandler();
-        this.userName = userName;
         this.clientSettings = Constants.DefaultClientSettings();
-        this.clientParameters = Constants.DefaultClientParams();
+        this.clientSettings.setHostName(userName);
         this.logger = Logger.getLogger(TikTokLive.class.getName());
     }
 
-
-
-
-    public TikTokLiveClientBuilder clientSettings(Consumer<ClientSettings> consumer) {
+    public TikTokLiveClientBuilder configure(Consumer<ClientSettings> consumer) {
         consumer.accept(clientSettings);
         return this;
     }
 
-    public TikTokLiveClientBuilder hostUserName(String userName) {
-        this.userName = userName;
-        return this;
-    }
-
-    public TikTokLiveClientBuilder clientParameters(Map<String, Object> clientParameters) {
-        this.clientParameters = clientParameters;
-        return this;
-    }
-
-    public TikTokLiveClientBuilder addClientParameters(String key, Object value) {
-        this.clientParameters.put(key, value);
-        return this;
-    }
-
     private void validate() {
 
         if (clientSettings.getTimeout() == null) {
             clientSettings.setTimeout(Duration.ofSeconds(Constants.DEFAULT_TIMEOUT));
         }
 
-        if (clientSettings.getPollingInterval() == null) {
-            clientSettings.setPollingInterval(Duration.ofSeconds(Constants.DEFAULT_POLLTIME));
-        }
-
         if (clientSettings.getClientLanguage() == null || clientSettings.getClientLanguage().equals("")) {
             clientSettings.setClientLanguage(Constants.DefaultClientSettings().getClientLanguage());
         }
 
-        if (clientSettings.getSocketBufferSize() < 500_000) {
-            clientSettings.setSocketBufferSize(Constants.DefaultClientSettings().getSocketBufferSize());
+
+        if (clientSettings.getHostName() == null || clientSettings.getHostName().equals("")) {
+            throw new TikTokLiveException("HostName can not be null");
         }
 
+        var params = clientSettings.getClientParameters();
+        params.put("app_language", clientSettings.getClientLanguage());
+        params.put("webcast_language", clientSettings.getClientLanguage());
 
-        if (userName == null || userName.equals("")) {
-            throw new RuntimeException("UserName can not be null");
+        logger.setLevel(clientSettings.getLogLevel());
+
+        if(clientSettings.isPrintToConsole() && clientSettings.getLogLevel() == Level.OFF)
+        {
+            logger.setLevel(Level.ALL);
         }
-
-        if (clientParameters == null) {
-            clientParameters = Constants.DefaultClientParams();
-        }
-
-        clientParameters.put("app_language", clientSettings.getClientLanguage());
-        clientParameters.put("webcast_language", clientSettings.getClientLanguage());
     }
 
     public LiveClient build() {
         validate();
 
 
-        var meta = new TikTokRoomInfo();
-        meta.setUserName(userName);
-
+        var tiktokRoomInfo = new TikTokRoomInfo();
+        tiktokRoomInfo.setUserName(clientSettings.getHostName());
 
         var cookieJar = new TikTokCookieJar();
         var requestFactory = new TikTokHttpRequestFactory(cookieJar);
-        var apiClient = new TikTokHttpApiClient(cookieJar, clientSettings, requestFactory);
-        var apiService = new TikTokApiService(apiClient, logger, clientParameters);
-        var giftManager = new TikTokGiftManager(logger, apiService, clientSettings);
-        var webResponseHandler = new WebResponseHandler(tikTokEventHandler,giftManager);
-        var webSocketClient = new TikTokWebsocketClient(logger,
+        var apiClient = new TikTokHttpApiClient(cookieJar, requestFactory);
+        var apiService = new TikTokApiService(apiClient, logger, clientSettings);
+        var giftManager = new TikTokGiftManager();
+        var webResponseHandler = new TikTokMessageHandlerRegistration(tikTokEventHandler, clientSettings, logger, giftManager, tiktokRoomInfo);
+        var webSocketClient = new TikTokWebSocketClient(logger,
                 cookieJar,
-                clientParameters,
-                requestFactory,
                 clientSettings,
                 webResponseHandler,
                 tikTokEventHandler);
 
-        return new TikTokLiveClient(meta, apiService, webSocketClient, giftManager, tikTokEventHandler, logger);
+        return new TikTokLiveClient(tiktokRoomInfo, apiService, webSocketClient, giftManager, tikTokEventHandler, clientSettings, logger);
     }
 
     public LiveClient buildAndRun() {
@@ -118,214 +91,230 @@ public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveCli
         return client;
     }
 
-    public TikTokLiveClientBuilder onUnhandledSocial(Consumer<TikTokUnhandledSocialEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class,event);
+
+    public TikTokLiveClientBuilder onUnhandledSocial(
+            TikTokEventConsumer<TikTokUnhandledSocialEvent> event) {
+        tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLinkMicFanTicket(Consumer<TikTokLinkMicFanTicketEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class,event);
+    public TikTokLiveClientBuilder onLinkMicFanTicket(
+            TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onEnvelope(Consumer<TikTokEnvelopeEvent> event) {
-        tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class,event);
+    public TikTokLiveClientBuilder onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event) {
+        tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onShopMessage(Consumer<TikTokShopMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokShopMessageEvent.class,event);
+    public TikTokLiveClientBuilder onShopMessage(TikTokEventConsumer<TikTokShopMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokShopMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onDetectMessage(Consumer<TikTokDetectMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokDetectMessageEvent.class,event);
+    public TikTokLiveClientBuilder onDetectMessage(
+            TikTokEventConsumer<TikTokDetectMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokDetectMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLinkLayerMessage(Consumer<TikTokLinkLayerMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkLayerMessageEvent.class,event);
+    public TikTokLiveClientBuilder onLinkLayerMessage(
+            TikTokEventConsumer<TikTokLinkLayerMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkLayerMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onConnected(Consumer<TikTokConnectedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokConnectedEvent.class,event);
+    public TikTokLiveClientBuilder onConnected(TikTokEventConsumer<TikTokConnectedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokConnectedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onCaption(Consumer<TikTokCaptionEvent> event) {
-        tikTokEventHandler.subscribe(TikTokCaptionEvent.class,event);
+    public TikTokLiveClientBuilder onCaption(TikTokEventConsumer<TikTokCaptionEvent> event) {
+        tikTokEventHandler.subscribe(TikTokCaptionEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onQuestion(Consumer<TikTokQuestionEvent> event) {
-        tikTokEventHandler.subscribe(TikTokQuestionEvent.class,event);
+    public TikTokLiveClientBuilder onQuestion(TikTokEventConsumer<TikTokQuestionEvent> event) {
+        tikTokEventHandler.subscribe(TikTokQuestionEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRoomPinMessage(Consumer<TikTokRoomPinMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomPinMessageEvent.class,event);
+    public TikTokLiveClientBuilder onRoomPinMessage(
+            TikTokEventConsumer<TikTokRoomPinMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomPinMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRoomMessage(Consumer<TikTokRoomMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomMessageEvent.class,event);
+    public TikTokLiveClientBuilder onRoomMessage(TikTokEventConsumer<TikTokRoomMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLivePaused(Consumer<TikTokLivePausedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLivePausedEvent.class,event);
+    public TikTokLiveClientBuilder onLivePaused(TikTokEventConsumer<TikTokLivePausedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLivePausedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLike(Consumer<TikTokLikeEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLikeEvent.class,event);
+    public TikTokLiveClientBuilder onLike(TikTokEventConsumer<TikTokLikeEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLinkMessage(Consumer<TikTokLinkMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMessageEvent.class,event);
+    public TikTokLiveClientBuilder onLinkMessage(TikTokEventConsumer<TikTokLinkMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onBarrageMessage(Consumer<TikTokBarrageMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokBarrageMessageEvent.class,event);
+    public TikTokLiveClientBuilder onBarrageMessage(
+            TikTokEventConsumer<TikTokBarrageMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokBarrageMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onGiftMessage(Consumer<TikTokGiftMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokGiftMessageEvent.class,event);
+    public TikTokLiveClientBuilder onGiftMessage(TikTokEventConsumer<TikTokGiftMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokGiftMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLinkMicArmies(Consumer<TikTokLinkMicArmiesEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class,event);
+    public TikTokLiveClientBuilder onLinkMicArmies(
+            TikTokEventConsumer<TikTokLinkMicArmiesEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onEmote(Consumer<TikTokEmoteEvent> event) {
-        tikTokEventHandler.subscribe(TikTokEmoteEvent.class,event);
+    public TikTokLiveClientBuilder onEmote(TikTokEventConsumer<TikTokEmoteEvent> event) {
+        tikTokEventHandler.subscribe(TikTokEmoteEvent.class, event);
         return this;
     }
 
     public TikTokLiveClientBuilder onUnauthorizedMember(
-            Consumer<TikTokUnauthorizedMemberEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class,event);
+            TikTokEventConsumer<TikTokUnauthorizedMemberEvent> event) {
+        tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onInRoomBanner(Consumer<TikTokInRoomBannerEvent> event) {
-        tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class,event);
+    public TikTokLiveClientBuilder onInRoomBanner(
+            TikTokEventConsumer<TikTokInRoomBannerEvent> event) {
+        tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLinkMicMethod(Consumer<TikTokLinkMicMethodEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class,event);
+    public TikTokLiveClientBuilder onLinkMicMethod(
+            TikTokEventConsumer<TikTokLinkMicMethodEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onSubscribe(Consumer<TikTokSubscribeEvent> event) {
-        tikTokEventHandler.subscribe(TikTokSubscribeEvent.class,event);
+    public TikTokLiveClientBuilder onSubscribe(TikTokEventConsumer<TikTokSubscribeEvent> event) {
+        tikTokEventHandler.subscribe(TikTokSubscribeEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onPollMessage(Consumer<TikTokPollMessageEvent> event) {
-        tikTokEventHandler.subscribe(TikTokPollMessageEvent.class,event);
+    public TikTokLiveClientBuilder onPollMessage(TikTokEventConsumer<TikTokPollMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokPollMessageEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onFollow(Consumer<TikTokFollowEvent> event) {
-        tikTokEventHandler.subscribe(TikTokFollowEvent.class,event);
+    public TikTokLiveClientBuilder onFollow(TikTokEventConsumer<TikTokFollowEvent> event) {
+        tikTokEventHandler.subscribe(TikTokFollowEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRoomViewerData(Consumer<TikTokRoomViewerDataEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomViewerDataEvent.class,event);
+    public TikTokLiveClientBuilder onRoomViewerData(
+            TikTokEventConsumer<TikTokRoomViewerDataEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomViewerDataEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onGoalUpdate(Consumer<TikTokGoalUpdateEvent> event) {
-        tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class,event);
+    public TikTokLiveClientBuilder onGoalUpdate(TikTokEventConsumer<TikTokGoalUpdateEvent> event) {
+        tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onComment(Consumer<TikTokCommentEvent> event) {
-        tikTokEventHandler.subscribe(TikTokCommentEvent.class,event);
+    public TikTokLiveClientBuilder onComment(TikTokEventConsumer<TikTokCommentEvent> event) {
+        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRankUpdate(Consumer<TikTokRankUpdateEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class,event);
+    public TikTokLiveClientBuilder onRankUpdate(TikTokEventConsumer<TikTokRankUpdateEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onIMDelete(Consumer<TikTokIMDeleteEvent> event) {
-        tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class,event);
+    public TikTokLiveClientBuilder onIMDelete(TikTokEventConsumer<TikTokIMDeleteEvent> event) {
+        tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLiveEnded(Consumer<TikTokLiveEndedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLiveEndedEvent.class,event);
+    public TikTokLiveClientBuilder onLiveEnded(TikTokEventConsumer<TikTokLiveEndedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLiveEndedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onError(Consumer<TikTokErrorEvent> event) {
-        tikTokEventHandler.subscribe(TikTokErrorEvent.class,event);
+    public TikTokLiveClientBuilder onError(TikTokEventConsumer<TikTokErrorEvent> event) {
+        tikTokEventHandler.subscribe(TikTokErrorEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onUnhandled(Consumer<TikTokUnhandledEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledEvent.class,event);
+    public TikTokLiveClientBuilder onUnhandled(TikTokEventConsumer<TikTokUnhandledEvent> event) {
+        tikTokEventHandler.subscribe(TikTokUnhandledEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onJoin(Consumer<TikTokJoinEvent> event) {
-        tikTokEventHandler.subscribe(TikTokJoinEvent.class,event);
+    public TikTokLiveClientBuilder onJoin(TikTokEventConsumer<TikTokJoinEvent> event) {
+        tikTokEventHandler.subscribe(TikTokJoinEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onRankText(Consumer<TikTokRankTextEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRankTextEvent.class,event);
+    public TikTokLiveClientBuilder onRankText(TikTokEventConsumer<TikTokRankTextEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRankTextEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onShare(Consumer<TikTokShareEvent> event) {
-        tikTokEventHandler.subscribe(TikTokShareEvent.class,event);
+    public TikTokLiveClientBuilder onShare(TikTokEventConsumer<TikTokShareEvent> event) {
+        tikTokEventHandler.subscribe(TikTokShareEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onUnhandledMember(Consumer<TikTokUnhandledMemberEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledMemberEvent.class,event);
+    public TikTokLiveClientBuilder onUnhandledMember(
+            TikTokEventConsumer<TikTokUnhandledMemberEvent> event) {
+        tikTokEventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onSubNotify(Consumer<TikTokSubNotifyEvent> event) {
-        tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class,event);
+    public TikTokLiveClientBuilder onSubNotify(TikTokEventConsumer<TikTokSubNotifyEvent> event) {
+        tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onLinkMicBattle(Consumer<TikTokLinkMicBattleEvent> event) {
-        tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class,event);
+    public TikTokLiveClientBuilder onLinkMicBattle(
+            TikTokEventConsumer<TikTokLinkMicBattleEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onDisconnected(Consumer<TikTokDisconnectedEvent> event) {
-        tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class,event);
+    public TikTokLiveClientBuilder onDisconnected(
+            TikTokEventConsumer<TikTokDisconnectedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onGiftBroadcast(Consumer<TikTokGiftBroadcastEvent> event) {
-        tikTokEventHandler.subscribe(TikTokGiftBroadcastEvent.class,event);
+    public TikTokLiveClientBuilder onGiftBroadcast(
+            TikTokEventConsumer<TikTokGiftBroadcastEvent> event) {
+        tikTokEventHandler.subscribe(TikTokGiftBroadcastEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onUnhandledControl(Consumer<TikTokUnhandledControlEvent> event) {
-        tikTokEventHandler.subscribe(TikTokUnhandledControlEvent.class,event);
+    public TikTokLiveClientBuilder onUnhandledControl(
+            TikTokEventConsumer<TikTokUnhandledControlEvent> event) {
+        tikTokEventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
         return this;
     }
 
-    public TikTokLiveClientBuilder onEvent(Consumer<TikTokEvent> event) {
-        tikTokEventHandler.subscribe(TikTokEvent.class,event);
+    public TikTokLiveClientBuilder onEvent(TikTokEventConsumer<TikTokEvent> event) {
+        tikTokEventHandler.subscribe(TikTokEvent.class, event);
         return this;
     }
 }
@@ -333,3 +322,6 @@ public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveCli
 
 
 
+
+
+

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

@@ -1,5 +1,7 @@
-package io.github.jwdeveloper.tiktok.live;
+package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.tiktok.live.ConnectionState;
+import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
 import lombok.Data;
 
 @Data

Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/TikTokEventHandler.java

@@ -1,40 +1,38 @@
 package io.github.jwdeveloper.tiktok.handlers;
+
+import io.github.jwdeveloper.tiktok.TikTokLiveClient;
 import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.TikTokEventConsumer;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Consumer;
 
-public class TikTokEventHandler  {
-    private final Map<String, Consumer> events;
+public class TikTokEventHandler {
+    private final Map<String, TikTokEventConsumer> events;
 
-    public TikTokEventHandler()
-    {
+    public TikTokEventHandler() {
         events = new HashMap<>();
     }
 
-    public void publish(TikTokEvent tikTokEvent)
-    {
-        if(events.containsKey(TikTokEvent.class.getSimpleName()))
-        {
+    public void publish(TikTokLiveClient tikTokLiveClient, TikTokEvent tikTokEvent) {
+        if (events.containsKey(TikTokEvent.class.getSimpleName())) {
             var handler = events.get(TikTokEvent.class.getSimpleName());
-            handler.accept(tikTokEvent);
+            handler.onEvent(tikTokLiveClient, tikTokEvent);
         }
 
         var name = tikTokEvent.getClass().getSimpleName();
-        if(!events.containsKey(name))
-        {
+        if (!events.containsKey(name)) {
             return;
         }
         var handler = events.get(name);
-        handler.accept(tikTokEvent);
+        handler.onEvent(tikTokLiveClient, tikTokEvent);
     }
 
-    public <T extends TikTokEvent> void subscribe(Class<?> clazz, Consumer<T> event)
-    {
-        events.put(clazz.getSimpleName(),event);
+    public <T extends TikTokEvent> void subscribe(Class<?> clazz, TikTokEventConsumer<T> event) {
+        events.put(clazz.getSimpleName(), event);
     }
 
-
-
+    public <T extends TikTokEvent> void unsubscribe(Class<?> clazz) {
+        events.remove(clazz);
+    }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/TikTokMessageHandler.java

@@ -1,12 +1,97 @@
 package io.github.jwdeveloper.tiktok.handlers;
 
 
+import com.google.protobuf.ByteString;
+import io.github.jwdeveloper.tiktok.ClientSettings;
+import io.github.jwdeveloper.tiktok.TikTokLiveClient;
 import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.messages.TikTokErrorEvent;
+import io.github.jwdeveloper.tiktok.events.messages.TikTokUnhandledEvent;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokMessageMappingException;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 
-public interface TikTokMessageHandler<T>
-{
-     Class<T> getHandleClazz();
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.logging.Logger;
 
-    TikTokEvent handle(WebcastResponse.Message message) throws Exception;
+
+public abstract class TikTokMessageHandler {
+
+    private final Map<String, io.github.jwdeveloper.tiktok.handler.TikTokMessageHandler> handlers;
+    private final TikTokEventHandler tikTokEventHandler;
+    private final ClientSettings clientSettings;
+    protected final Logger logger;
+
+    public TikTokMessageHandler(TikTokEventHandler tikTokEventHandler,ClientSettings clientSettings, Logger logger) {
+        handlers = new HashMap<>();
+        this.tikTokEventHandler = tikTokEventHandler;
+        this.clientSettings = clientSettings;
+        this.logger = logger;
+        init();
+    }
+
+    public abstract void init();
+
+    public void register(Class<?> clazz, Function<WebcastResponse.Message, TikTokEvent> func) {
+        handlers.put(clazz.getSimpleName(), func::apply);
+    }
+
+    public void register(Class<?> input, Class<?> output) {
+        register(input, (e) -> mapMessageToEvent(input, output, e));
+    }
+
+    public void handle(TikTokLiveClient client, WebcastResponse webcastResponse) {
+        for (var message : webcastResponse.getMessagesList()) {
+            try
+            {
+                if(clientSettings.isPrintMessageData())
+                {
+                    var type=  message.getType();
+                    var base64 =     Base64.getEncoder().encodeToString(message.getBinary().toByteArray());
+                    logger.info(type+": \n "+base64);
+                }
+                handleSingleMessage(client, message);
+            } catch (Exception e) {
+                var exception = new TikTokLiveMessageException(message, webcastResponse, e);
+                tikTokEventHandler.publish(client, new TikTokErrorEvent(exception));
+            }
+        }
+    }
+
+    private void handleSingleMessage(TikTokLiveClient client, WebcastResponse.Message message) throws Exception {
+        if (!handlers.containsKey(message.getType())) {
+            tikTokEventHandler.publish(client, new TikTokUnhandledEvent(message));
+            return;
+        }
+        var handler = handlers.get(message.getType());
+        var tiktokEvent = handler.handle(message);
+        tikTokEventHandler.publish(client, tiktokEvent);
+    }
+
+    protected TikTokEvent mapMessageToEvent(Class<?> inputClazz, Class<?> outputClass, WebcastResponse.Message message) {
+        try {
+            var parseMethod = inputClazz.getDeclaredMethod("parseFrom", ByteString.class);
+            var deserialized = parseMethod.invoke(null, message.getBinary());
+
+            var constructors = Arrays.stream(outputClass.getConstructors())
+                    .filter(ea -> Arrays.stream(ea.getParameterTypes())
+                            .toList()
+                            .contains(inputClazz))
+                    .findFirst();
+
+            if(constructors.isEmpty())
+            {
+                throw new TikTokMessageMappingException(inputClazz, outputClass, "Unable to find constructor with input class type");
+            }
+
+            var tiktokEvent = constructors.get().newInstance(deserialized);
+            return (TikTokEvent) tiktokEvent;
+        } catch (Exception ex) {
+            throw new TikTokMessageMappingException(inputClazz, outputClass, ex);
+        }
+    }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/TikTokMessageHandlerRegistration.java

@@ -1,6 +1,8 @@
 package io.github.jwdeveloper.tiktok.handlers;
 
+import io.github.jwdeveloper.tiktok.ClientSettings;
 import io.github.jwdeveloper.tiktok.TikTokGiftManager;
+import io.github.jwdeveloper.tiktok.TikTokRoomInfo;
 import io.github.jwdeveloper.tiktok.events.TikTokEvent;
 import io.github.jwdeveloper.tiktok.events.messages.*;
 import io.github.jwdeveloper.tiktok.events.objects.TikTokGift;
@@ -9,15 +11,22 @@ import io.github.jwdeveloper.tiktok.models.GiftId;
 import io.github.jwdeveloper.tiktok.models.SocialTypes;
 import lombok.SneakyThrows;
 
+import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-public class WebResponseHandler extends WebResponseHandlerBase {
+public class TikTokMessageHandlerRegistration extends TikTokMessageHandler {
     private final TikTokGiftManager giftManager;
+    private final TikTokRoomInfo roomInfo;
 
-    public WebResponseHandler(TikTokEventHandler tikTokEventHandler, TikTokGiftManager giftManager) {
-        super(tikTokEventHandler);
+    public TikTokMessageHandlerRegistration(TikTokEventHandler tikTokEventHandler,
+                                            ClientSettings clientSettings,
+                                            Logger logger,
+                                            TikTokGiftManager giftManager,
+                                            TikTokRoomInfo roomInfo) {
+        super(tikTokEventHandler, clientSettings, logger);
         this.giftManager = giftManager;
+        this.roomInfo = roomInfo;
     }
 
     @Override
@@ -30,7 +39,7 @@ public class WebResponseHandler extends WebResponseHandlerBase {
 
         //Room status events
         register(WebcastLiveIntroMessage.class, TikTokRoomMessageEvent.class);
-        register(WebcastRoomUserSeqMessage.class, TikTokRoomViewerDataEvent.class); //TODO update viewer count    ViewerCount = userSeqMessage.ViewerCount;
+        register(WebcastRoomUserSeqMessage.class, this::handleRoomUserSeqMessage);
         register(RoomMessage.class, TikTokRoomMessageEvent.class);
         register(WebcastRoomMessage.class, TikTokRoomMessageEvent.class);
         register(WebcastCaptionMessage.class, TikTokCaptionEvent.class);
@@ -74,9 +83,9 @@ public class WebResponseHandler extends WebResponseHandlerBase {
     }
 
 
+
     @SneakyThrows
-    private TikTokEvent handleWebcastControlMessage(WebcastResponse.Message msg)
-    {
+    private TikTokEvent handleWebcastControlMessage(WebcastResponse.Message msg) {
         var message = WebcastControlMessage.parseFrom(msg.getBinary());
         return switch (message.getAction()) {
             case STREAM_PAUSED -> new TikTokLivePausedEvent();
@@ -88,29 +97,7 @@ public class WebResponseHandler extends WebResponseHandlerBase {
     @SneakyThrows
     private TikTokEvent handleGift(WebcastResponse.Message msg) {
         var giftMessage = WebcastGiftMessage.parseFrom(msg.getBinary());
-        var giftId = new GiftId(giftMessage.getGiftId(), giftMessage.getSender().getUniqueId());
-
-        var activeGifts = giftManager.getActiveGifts();
-        if (activeGifts.containsKey(giftId)) {
-            //   Debug.Log($"Updating Gift[{giftId.Gift}]Amount[{message.Amount}]");
-            var gift = activeGifts.get(giftId);
-            gift.setAmount(giftMessage.getAmount());
-        } else {
-            TikTokGift newGift = new TikTokGift(giftMessage);
-            activeGifts.put(giftId, newGift);
-            //   Debug.Log($"New Gift[{giftId.Gift}]Amount[{message.Amount}]");
-            //    RunEvent(OnGift, newGift);
-        }
-        if (giftMessage.getRepeatEnd()) {
-            //if (ShouldLog(LogLevel.Verbose))
-            //   Debug.Log($"GiftStreak Ended: [{giftId.Gift}] Amount[{message.Amount}]")
-            var gift = activeGifts.get(giftId);
-            gift.setStreakFinished(true);
-            activeGifts.remove(gift);
-        }
-
-        //   Debug.Log($"Handling GiftMessage");
-
+        giftManager.updateActiveGift(giftMessage);
         return new TikTokGiftMessageEvent(giftMessage);
     }
 
@@ -119,7 +106,7 @@ public class WebResponseHandler extends WebResponseHandlerBase {
         var message = WebcastSocialMessage.parseFrom(msg.getBinary());
 
         String type = message.getHeader().getSocialData().getType();
-        Pattern pattern = Pattern.compile("pm_mt_guidance_viewer_([0-9]+)_share");
+        Pattern pattern = Pattern.compile("\\d+");
         Matcher matcher = pattern.matcher(type);
         if (matcher.find()) {
             var value = matcher.group(0);
@@ -146,4 +133,11 @@ public class WebResponseHandler extends WebResponseHandlerBase {
             default -> new TikTokUnhandledMemberEvent(message);
         };
     }
+
+    private TikTokEvent handleRoomUserSeqMessage(WebcastResponse.Message msg)
+    {
+        var event = (TikTokRoomViewerDataEvent)mapMessageToEvent(WebcastRoomUserSeqMessage.class, TikTokRoomViewerDataEvent.class, msg);
+        roomInfo.setViewersCount(event.getViewerCount());
+        return event;
+    }
 }

Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/WebResponseHandlerBase.java

@@ -1,89 +0,0 @@
-package io.github.jwdeveloper.tiktok.handlers;
-
-
-import com.google.protobuf.ByteString;
-import io.github.jwdeveloper.tiktok.events.TikTokEvent;
-import io.github.jwdeveloper.tiktok.events.messages.TikTokErrorEvent;
-import io.github.jwdeveloper.tiktok.events.messages.TikTokUnhandledEvent;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageParsingException;
-import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
-
-import java.util.Arrays;
-import java.util.Base64;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.Function;
-
-
-public abstract class WebResponseHandlerBase {
-
-    private final Map<String, TikTokMessageHandler> handlers;
-    private final TikTokEventHandler tikTokEventHandler;
-
-    public WebResponseHandlerBase(TikTokEventHandler tikTokEventHandler) {
-        handlers = new HashMap<>();
-        this.tikTokEventHandler = tikTokEventHandler;
-        init();
-    }
-
-    public abstract void init();
-
-    public void register(Class<?> input, Class<?> output) {
-        register(input, (e) ->
-        {
-            try {
-                var parseMethod = input.getDeclaredMethod("parseFrom", ByteString.class);
-                var deserialized = parseMethod.invoke(null, e.getBinary());
-
-                var constructors = Arrays.stream(output.getConstructors()).filter(ea -> Arrays.stream(ea.getParameterTypes()).toList().contains(input)).findFirst();
-
-                var tiktokEvent = constructors.get().newInstance(deserialized);
-                return (TikTokEvent)tiktokEvent;
-            } catch (Exception ex)
-            {
-                throw new TikTokLiveMessageParsingException("Unable to handle parsing from class: " + input.getSimpleName() + " to class " + output.getSimpleName(), ex);
-            }
-        });
-    }
-
-    public <T> void register(Class clazz, Function<WebcastResponse.Message, TikTokEvent> func) {
-        var haandler = new TikTokMessageHandler<T>() {
-            @Override
-            public Class<T> getHandleClazz() {
-                return clazz;
-            }
-
-            @Override
-            public TikTokEvent handle(WebcastResponse.Message message) throws Exception {
-                return func.apply(message);
-            }
-        };
-
-        handlers.put(haandler.getHandleClazz().getSimpleName(), haandler);
-    }
-
-    public void handle(WebcastResponse webcastResponse) {
-        for (var message : webcastResponse.getMessagesList()) {
-            try {
-                handleSingleMessage(message);
-            } catch (Exception e)
-            {
-                var decoded = Base64.getEncoder().encodeToString(message.getBinary().toByteArray());
-
-                var exception = new TikTokLiveException("Error whilst Handling Message. Stopping Client. Final Message: \n"+decoded, e);
-                tikTokEventHandler.publish(new TikTokErrorEvent(exception));
-            }
-        }
-    }
-
-    private void handleSingleMessage(WebcastResponse.Message message) throws Exception {
-        if (!handlers.containsKey(message.getType())) {
-            tikTokEventHandler.publish(new TikTokUnhandledEvent(message));
-            return;
-        }
-        var handler = handlers.get(message.getType());
-        var tiktokEvent = handler.handle(message);
-        tikTokEventHandler.publish(tiktokEvent);
-    }
-}

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

@@ -44,8 +44,8 @@ public class HttpUtils
                     builder.append("&");
                 }
 
-                final String encodedKey = URLEncoder.encode(param.getKey().toString(), StandardCharsets.UTF_8.toString());
-                final String encodedValue = URLEncoder.encode(param.getValue().toString(), StandardCharsets.UTF_8.toString());
+                final String encodedKey = URLEncoder.encode(param.getKey(), StandardCharsets.UTF_8);
+                final String encodedValue = URLEncoder.encode(param.getValue().toString(), StandardCharsets.UTF_8);
                 builder.append(encodedKey).append("=").append(encodedValue);
                 first = true;
             }

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

@@ -1,9 +1,11 @@
 package io.github.jwdeveloper.tiktok.http;
 
 import com.google.gson.Gson;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.ClientSettings;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveOfflineHostException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 import io.github.jwdeveloper.tiktok.live.LiveRoomMeta;
-import io.github.jwdeveloper.tiktok.models.gifts.TikTokGift;
+import io.github.jwdeveloper.tiktok.models.gifts.TikTokGiftInfo;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 
 import java.util.HashMap;
@@ -15,12 +17,12 @@ import java.util.regex.Pattern;
 public class TikTokApiService {
     private final TikTokHttpApiClient apiClient;
     private final Logger logger;
-    private final Map<String, Object> clientParams;
+    private final ClientSettings clientSettings;
 
-    public TikTokApiService(TikTokHttpApiClient apiClient, Logger logger, Map<String, Object> clientParams) {
+    public TikTokApiService(TikTokHttpApiClient apiClient, Logger logger, ClientSettings clientSettings) {
         this.apiClient = apiClient;
         this.logger = logger;
-        this.clientParams = clientParams;
+        this.clientSettings = clientSettings;
     }
 
     public String fetchRoomId(String userName) {
@@ -29,7 +31,7 @@ public class TikTokApiService {
         try {
             html = apiClient.GetLivestreamPage(userName);
         } catch (Exception e) {
-            throw new RuntimeException("Failed to fetch room id from WebCast, see stacktrace for more info.", e);
+            throw new TikTokLiveRequestException("Failed to fetch room id from WebCast, see stacktrace for more info.", e);
         }
 
         Pattern firstPattern = Pattern.compile("room_id=([0-9]*)");
@@ -48,10 +50,10 @@ public class TikTokApiService {
         }
 
         if (id.isEmpty()) {
-            throw new TikTokLiveException("Unable to fetch room ID");
+            throw new TikTokLiveOfflineHostException("Unable to fetch room ID, live host could be offline or name is misspelled");
         }
 
-        clientParams.put("room_id", id);
+        clientSettings.getClientParameters().put("room_id", id);
         logger.info("RoomID -> "+id);
         return id;
     }
@@ -60,7 +62,7 @@ public class TikTokApiService {
     public LiveRoomMeta fetchRoomInfo() {
         logger.info("Fetch RoomInfo");
         try {
-            var response = apiClient.GetJObjectFromWebcastAPI("room/info/", clientParams);
+            var response = apiClient.GetJObjectFromWebcastAPI("room/info/", clientSettings.getClientParameters());
             if (!response.has("data")) {
                 return new LiveRoomMeta();
             }
@@ -78,7 +80,7 @@ public class TikTokApiService {
             logger.info("RoomInfo status -> "+info.getStatus());
             return info;
         } catch (Exception e) {
-            throw new TikTokLiveException("Failed to fetch room info from WebCast, see stacktrace for more info.", e);
+            throw new TikTokLiveRequestException("Failed to fetch room info from WebCast, see stacktrace for more info.", e);
         }
     }
 
@@ -86,20 +88,20 @@ public class TikTokApiService {
     {
         logger.info("Fetch ClientData");
         try {
-            var response = apiClient.GetDeserializedMessage("im/fetch/", clientParams);
-            clientParams.put("cursor",response.getCursor());
-            clientParams.put("internal_ext", response.getAckIds());
+            var response = apiClient.GetDeserializedMessage("im/fetch/", clientSettings.getClientParameters());
+            clientSettings.getClientParameters().put("cursor",response.getCursor());
+            clientSettings.getClientParameters().put("internal_ext", response.getAckIds());
             return response;
         }
         catch (Exception e)
         {
-            throw new TikTokLiveException("Failed to fetch client data", e);
+            throw new TikTokLiveRequestException("Failed to fetch client data", e);
         }
     }
 
-    public Map<Integer, TikTokGift> fetchAvailableGifts() {
+    public Map<Integer, TikTokGiftInfo> fetchAvailableGifts() {
         try {
-            var response = apiClient.GetJObjectFromWebcastAPI("gift/list/", clientParams);
+            var response = apiClient.GetJObjectFromWebcastAPI("gift/list/", clientSettings.getClientParameters());
             if(!response.has("data"))
             {
                 return new HashMap<>();
@@ -110,17 +112,17 @@ public class TikTokApiService {
                 return new HashMap<>();
             }
             var giftsJsonList = dataJson.get("gifts").getAsJsonArray();
-            var gifts = new HashMap<Integer, TikTokGift>();
+            var gifts = new HashMap<Integer, TikTokGiftInfo>();
             var gson = new Gson();
             for(var jsonGift : giftsJsonList)
             {
-                var gift = gson.fromJson(jsonGift, TikTokGift.class);
+                var gift = gson.fromJson(jsonGift, TikTokGiftInfo.class);
                 logger.info("Found Available Gift "+ gift.getName()+ " with ID "+gift.getId());
                 gifts.put(gift.getId(),gift);
             }
             return gifts;
         } catch (Exception e) {
-            throw new TikTokLiveException("Failed to fetch giftTokens from WebCast, see stacktrace for more info.", e);
+            throw new TikTokLiveRequestException("Failed to fetch giftTokens from WebCast, see stacktrace for more info.", e);
         }
     }
 }

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

@@ -4,7 +4,7 @@ import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import io.github.jwdeveloper.tiktok.ClientSettings;
 import io.github.jwdeveloper.tiktok.Constants;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 
 import java.net.URI;
@@ -16,27 +16,23 @@ import java.util.Map;
 import java.util.TreeMap;
 
 public class TikTokHttpApiClient {
-    private final ClientSettings clientSettings;
     private final TikTokHttpRequestFactory requestFactory;
     private final TikTokCookieJar tikTokCookieJar;
 
-
-    public TikTokHttpApiClient(TikTokCookieJar tikTokCookieJar, ClientSettings clientSettings, TikTokHttpRequestFactory requestFactory) {
-        this.clientSettings = clientSettings;
+    public TikTokHttpApiClient(TikTokCookieJar tikTokCookieJar,  TikTokHttpRequestFactory requestFactory) {
         this.requestFactory = requestFactory;
         this.tikTokCookieJar = tikTokCookieJar;
     }
 
-
     public String GetLivestreamPage(String userName) {
 
         var url = Constants.TIKTOK_URL_WEB + "@" + userName + "/live/";
-        var get = getRequest(url, null, false);
+        var get = getRequest(url, null);
         return get;
     }
 
     public JsonObject GetJObjectFromWebcastAPI(String path, Map<String, Object> parameters) {
-        var get = getRequest(Constants.TIKTOK_URL_WEBCAST + path, parameters, false);
+        var get = getRequest(Constants.TIKTOK_URL_WEBCAST + path, parameters);
         var json = JsonParser.parseString(get);
         var jsonObject = json.getAsJsonObject();
         return jsonObject;
@@ -49,12 +45,11 @@ public class TikTokHttpApiClient {
         }
         catch (Exception e)
         {
-            throw new TikTokLiveException("Unable to deserialize message: "+path,e);
+            throw new TikTokLiveRequestException("Unable to deserialize message: "+path,e);
         }
     }
 
-
-    private String getRequest(String url, Map<String, Object> parameters, boolean signURL) {
+    private String getRequest(String url, Map<String, Object> parameters) {
         if (parameters == null) {
             parameters = new HashMap<>();
         }
@@ -86,7 +81,7 @@ public class TikTokHttpApiClient {
         }
         catch (Exception e)
         {
-            throw new TikTokLiveException("unabel to send signature");
+            throw new TikTokLiveRequestException("Unable to send signature");
         }
     }
 
@@ -112,7 +107,7 @@ public class TikTokHttpApiClient {
             requestFactory.setAgent(userAgent);
             return signedUrl;
         } catch (Exception e) {
-            throw new TikTokLiveException("Insufficent values have been supplied for signing. Likely due to an update. Post an issue on GitHub.", e);
+            throw new TikTokLiveRequestException("Insufficient values have been supplied for signing. Likely due to an update. Post an issue on GitHub.", e);
         }
     }
 

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

@@ -2,10 +2,10 @@ package io.github.jwdeveloper.tiktok.http;
 
 
 import io.github.jwdeveloper.tiktok.Constants;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 import lombok.SneakyThrows;
 
 import java.net.CookieManager;
-import java.net.ProxySelector;
 import java.net.URI;
 import java.net.URLEncoder;
 import java.net.http.HttpClient;
@@ -18,24 +18,16 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-public class TikTokHttpRequestFactory implements TikTokHttpRequest
-{
-    private CookieManager cookieManager;
-    private HttpClient client;
-
-    private Duration timeout;
-
-    private ProxySelector webProxy;
+public class TikTokHttpRequestFactory implements TikTokHttpRequest {
+    private final CookieManager cookieManager;
+    private final Map<String, String> defaultHeaders;
+    private final TikTokCookieJar tikTokCookieJar;
+    private final HttpClient client;
     private String query;
-    private Boolean sent;
-    private Map<String, String> defaultHeaders;
-
-    private TikTokCookieJar tikTokCookieJar;
 
     public TikTokHttpRequestFactory(TikTokCookieJar tikTokCookieJar) {
-
-        cookieManager = new CookieManager();
         this.tikTokCookieJar = tikTokCookieJar;
+        this.cookieManager = new CookieManager();
         defaultHeaders = Constants.DefaultRequestHeaders();
         client = HttpClient.newBuilder()
                 .cookieHandler(cookieManager)
@@ -43,8 +35,7 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest
                 .build();
     }
 
-    public WebSocket.Builder  openSocket()
-    {
+    public WebSocket.Builder openSocket() {
         return client.newWebSocketBuilder();
     }
 
@@ -52,26 +43,21 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest
     public String Get(String url) {
         var uri = URI.create(url);
         var request = HttpRequest.newBuilder().GET();
-        for(var header : defaultHeaders.entrySet())
-        {
-            //request.setHeader(header.getKey(),header.getValue());
-        }
         if (query != null) {
             var baseUri = uri.toString();
             var requestUri = URI.create(baseUri + "?" + query);
             request.uri(requestUri);
         }
 
-       return GetContent(request.build());
+        return GetContent(request.build());
     }
 
     @SneakyThrows
     public String Post(String url, HttpRequest.BodyPublisher data) {
         var uri = URI.create(url);
         var request = HttpRequest.newBuilder().POST(data);
-        for(var header : defaultHeaders.entrySet())
-        {
-            request.setHeader(header.getKey(),header.getValue());
+        for (var header : defaultHeaders.entrySet()) {
+            request.setHeader(header.getKey(), header.getValue());
         }
         if (query != null) {
             var baseUri = uri.toString();
@@ -81,14 +67,12 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest
         return GetContent(request.build());
     }
 
-    public TikTokHttpRequest setHeader(String key, String value)
-    {
-        defaultHeaders.put(key,value);
+    public TikTokHttpRequest setHeader(String key, String value) {
+        defaultHeaders.put(key, value);
         return this;
     }
 
-    public TikTokHttpRequest setAgent( String value)
-    {
+    public TikTokHttpRequest setAgent(String value) {
         defaultHeaders.put("User-Agent", value);
         return this;
     }
@@ -111,26 +95,18 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest
     }
 
 
-   
-
-
     private String GetContent(HttpRequest request) throws Exception {
         var response = client.send(request, HttpResponse.BodyHandlers.ofString());
-        sent = true;
-        if (response.statusCode()  == 404)
-        {
-            throw new RuntimeException("Request responded with 404 NOT_FOUND");
+        if (response.statusCode() == 404) {
+            throw new TikTokLiveRequestException("Request responded with 404 NOT_FOUND");
         }
 
-        if(response.statusCode() != 200)
-        {
-            throw new RuntimeException("Request was unsuccessful "+response.statusCode());
+        if (response.statusCode() != 200) {
+            throw new TikTokLiveRequestException("Request was unsuccessful " + response.statusCode());
         }
 
-
         var cookies = response.headers().allValues("Set-Cookie");
-        for(var cookie : cookies)
-        {
+        for (var cookie : cookies) {
             var split = cookie.split(";")[0].split("=");
             var uri = request.uri();
 
@@ -139,9 +115,9 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest
             var value = split[1];
             tikTokCookieJar.set(key, value);
 
-            var map = new HashMap<String,List<String>>();
-            map.put(key,List.of(value));
-            cookieManager.put(uri,map);
+            var map = new HashMap<String, List<String>>();
+            map.put(key, List.of(value));
+            cookieManager.put(uri, map);
 
         }
         return response.body();

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

@@ -3,68 +3,62 @@ package io.github.jwdeveloper.tiktok.websocket;
 
 import io.github.jwdeveloper.tiktok.ClientSettings;
 import io.github.jwdeveloper.tiktok.Constants;
+import io.github.jwdeveloper.tiktok.TikTokLiveClient;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventHandler;
-import io.github.jwdeveloper.tiktok.handlers.WebResponseHandler;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
 import io.github.jwdeveloper.tiktok.http.HttpUtils;
 import io.github.jwdeveloper.tiktok.http.TikTokCookieJar;
 import io.github.jwdeveloper.tiktok.http.TikTokHttpRequestFactory;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+import org.java_websocket.client.WebSocketClient;
 
 import java.net.URI;
 import java.net.http.WebSocket;
-import java.nio.ByteBuffer;
-import java.time.Duration;
 import java.util.HashMap;
-import java.util.Map;
 import java.util.TreeMap;
 import java.util.logging.Logger;
 
-public class TikTokWebsocketClient {
+public class TikTokWebSocketClient {
     private final Logger logger;
-    private final Map<String, Object> clientParams;
     private final ClientSettings clientSettings;
     private final TikTokCookieJar tikTokCookieJar;
-    private final TikTokHttpRequestFactory factory;
-    private final WebResponseHandler webResponseHandler;
+    private final TikTokMessageHandlerRegistration webResponseHandler;
     private final TikTokEventHandler tikTokEventHandler;
 
-    private WebSocket webSocket;
-
+    private WebSocketClient webSocketClient;
     private boolean isConnected;
+    private TikTokLiveClient tikTokLiveClient;
 
-    public TikTokWebsocketClient(Logger logger,
+    public TikTokWebSocketClient(Logger logger,
                                  TikTokCookieJar tikTokCookieJar,
-                                 Map<String, Object> clientParams,
-                                 TikTokHttpRequestFactory factory,
                                  ClientSettings clientSettings,
-                                 WebResponseHandler webResponseHandler,
+                                 TikTokMessageHandlerRegistration webResponseHandler,
                                  TikTokEventHandler tikTokEventHandler) {
         this.logger = logger;
-        this.clientParams = clientParams;
         this.tikTokCookieJar = tikTokCookieJar;
         this.clientSettings = clientSettings;
-        this.factory = factory;
         this.webResponseHandler = webResponseHandler;
         this.tikTokEventHandler = tikTokEventHandler;
         isConnected = false;
     }
 
-    public void start(WebcastResponse webcastResponse)
-    {
-        if(isConnected)
-        {
+    public void start(WebcastResponse webcastResponse, TikTokLiveClient tikTokLiveClient) {
+        this.tikTokLiveClient = tikTokLiveClient;
+        if (isConnected) {
             stop();
         }
         if (webcastResponse.getSocketUrl().isEmpty() || webcastResponse.getSocketParamsList().isEmpty()) {
             throw new TikTokLiveException("Could not find Room");
         }
         try {
-            var url =getWebSocketUrl(webcastResponse);
-            webSocket =startWebSocket(url);
+            var url = getWebSocketUrl(webcastResponse);
             if (clientSettings.isHandleExistingMessagesOnConnect()) {
-                //  HandleWebcastMessages(webcastResponse);
+                logger.info("Handling existing messages");
+                webResponseHandler.handle(tikTokLiveClient, webcastResponse);
             }
+            webSocketClient = startWebSocket(url);
+            webSocketClient.connect();
         } catch (Exception e) {
             throw new TikTokLiveException("Failed to connect to the websocket", e);
         }
@@ -78,33 +72,26 @@ public class TikTokWebsocketClient {
         var headers = Constants.DefaultRequestHeaders();
 
 
-        var clone = new TreeMap<>(clientParams);
+        var clone = new TreeMap<>(clientSettings.getClientParameters());
         clone.putAll(headers);
         clone.put(name, value);
         var url = webcastResponse.getSocketUrl();
         return HttpUtils.parseParametersEncode(url, clone);
     }
 
-    private WebSocket startWebSocket(String url) throws Exception {
+    private WebSocketClient startWebSocket(String url) {
         var cookie = tikTokCookieJar.parseCookies();
-        //  System.out.println("WssIP: " + url);
-        //  System.out.println("Cookie: " + cookie);
-
         var map = new HashMap<String, String>();
         map.put("Cookie", cookie);
 
-       return factory.openSocket()
-                .subprotocols("echo-protocol")
-                .connectTimeout(Duration.ofSeconds(15))
-                .header("Cookie", cookie)
-                .buildAsync(URI.create(url), new TikTokWebSocketListener(webResponseHandler, tikTokEventHandler)).get();
+        return new TikTokWebSocketListener(URI.create(url), map, 3000, webResponseHandler, tikTokEventHandler, tikTokLiveClient);
     }
 
 
+
     public void stop() {
-        if(isConnected && webSocket != null)
-        {
-            webSocket.sendClose(WebSocket.NORMAL_CLOSURE, "ok");
+        if (isConnected && webSocketClient != null) {
+            webSocketClient.close();
         }
     }
 }

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

@@ -1,84 +1,103 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
-
+import com.google.protobuf.ByteString;
+import io.github.jwdeveloper.tiktok.TikTokLiveClient;
 import io.github.jwdeveloper.tiktok.events.messages.TikTokConnectedEvent;
 import io.github.jwdeveloper.tiktok.events.messages.TikTokDisconnectedEvent;
 import io.github.jwdeveloper.tiktok.events.messages.TikTokErrorEvent;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageParsingException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokProtocolBufferException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventHandler;
-import io.github.jwdeveloper.tiktok.handlers.WebResponseHandler;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
 import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketAck;
 import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketMessage;
+import org.java_websocket.client.WebSocketClient;
+import org.java_websocket.drafts.Draft_6455;
+import org.java_websocket.handshake.ServerHandshake;
 
-import java.io.ByteArrayOutputStream;
+import java.net.URI;
 import java.net.http.WebSocket;
 import java.nio.ByteBuffer;
-import java.util.concurrent.CompletionStage;
+import java.util.Map;
+import java.util.Optional;
 
+public class TikTokWebSocketListener extends WebSocketClient {
 
-public class TikTokWebSocketListener implements java.net.http.WebSocket.Listener {
-
-    private final ByteArrayOutputStream accumulatedData = new ByteArrayOutputStream();
-    private final WebResponseHandler webResponseHandler;
+    private final TikTokMessageHandlerRegistration webResponseHandler;
     private final TikTokEventHandler tikTokEventHandler;
+    private final TikTokLiveClient tikTokLiveClient;
 
-    public TikTokWebSocketListener(WebResponseHandler webResponseHandler, TikTokEventHandler tikTokEventHandler) {
+    public TikTokWebSocketListener(URI serverUri,
+                                   Map<String, String> httpHeaders,
+                                   int connectTimeout,
+                                   TikTokMessageHandlerRegistration webResponseHandler,
+                                   TikTokEventHandler tikTokEventHandler,
+                                   TikTokLiveClient tikTokLiveClient) {
+        super(serverUri, new Draft_6455(), httpHeaders,connectTimeout);
         this.webResponseHandler = webResponseHandler;
         this.tikTokEventHandler = tikTokEventHandler;
+        this.tikTokLiveClient = tikTokLiveClient;
     }
 
+
     @Override
-    public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
+    public void onOpen(ServerHandshake serverHandshake) {
+        tikTokEventHandler.publish(tikTokLiveClient,new TikTokConnectedEvent());
+        sendPing();
+    }
+
+
+    @Override
+    public void onMessage(ByteBuffer bytes)
+    {
         try {
-            var bytes = new byte[data.remaining()];
-            data.get(bytes);
-            accumulatedData.write(bytes);
-            if (last) {
-                handleBinary(webSocket, accumulatedData.toByteArray());
-                accumulatedData.reset();
-            }
+            handleBinary(bytes.array());
         } catch (Exception e) {
-            tikTokEventHandler.publish(new TikTokErrorEvent(e));
+            tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(e));
         }
-        webSocket.request(1);
-        return null;
+        sendPing();
     }
 
     @Override
-    public void onOpen(java.net.http.WebSocket webSocket) {
-        tikTokEventHandler.publish(new TikTokConnectedEvent());
-        webSocket.request(1);
+    public void onClose(int i, String s, boolean b) {
+        tikTokEventHandler.publish(tikTokLiveClient,new TikTokDisconnectedEvent());
     }
 
     @Override
-    public void onError(java.net.http.WebSocket webSocket, Throwable error) {
-        tikTokEventHandler.publish(new TikTokErrorEvent(error));
-        webSocket.request(1);
+    public void onError(Exception error) {
+        tikTokEventHandler.publish(tikTokLiveClient,new TikTokErrorEvent(error));
+        sendPing();
     }
 
-    @Override
-    public CompletionStage<?> onClose(java.net.http.WebSocket webSocket, int statusCode, String reason) {
-        tikTokEventHandler.publish(new TikTokDisconnectedEvent());
-        return java.net.http.WebSocket.Listener.super.onClose(webSocket, statusCode, reason);
+    private void handleBinary(byte[] buffer) {
+        var websocketMessageOptional = getWebcastWebsocketMessage(buffer);
+        if (websocketMessageOptional.isEmpty()) {
+            return;
+        }
+        var websocketMessage = websocketMessageOptional.get();
+        sendAckId(websocketMessage.getId());
+
+        var webResponse = getWebResponseMessage(websocketMessage.getBinary());
+        webResponseHandler.handle(tikTokLiveClient, webResponse);
     }
 
-    private void handleBinary(WebSocket webSocket, byte[] buffer) {
+    private Optional<WebcastWebsocketMessage> getWebcastWebsocketMessage(byte[] buffer) {
         try {
-
             var websocketMessage = WebcastWebsocketMessage.parseFrom(buffer);
             if (websocketMessage.getBinary().isEmpty()) {
-                return;
-            }
-            sendAckId(webSocket, websocketMessage.getId());
-            try {
-                var response = WebcastResponse.parseFrom(websocketMessage.getBinary());
-                webResponseHandler.handle(response);
-            } catch (Exception e) {
-                throw new TikTokLiveMessageParsingException("Unable to read WebcastResponse", e);
+                return Optional.empty();
             }
+            return Optional.of(websocketMessage);
         } catch (Exception e) {
-            throw new TikTokLiveMessageParsingException("Unable to read WebcastWebsocketMessage", e);
+            throw new TikTokProtocolBufferException("Unable to parse WebcastWebsocketMessage", buffer, e);
+        }
+    }
+
+    private WebcastResponse getWebResponseMessage(ByteString buffer) {
+        try {
+            return WebcastResponse.parseFrom(buffer);
+        } catch (Exception e) {
+            throw new TikTokProtocolBufferException("Unable to parse WebcastResponse", buffer.toByteArray(), e);
         }
     }
 
@@ -94,13 +113,19 @@ public class TikTokWebSocketListener implements java.net.http.WebSocket.Listener
         }
     }
 
-    private void sendAckId(WebSocket webSocket, long id) {
+    private void sendAckId(long id) {
         var serverInfo = WebcastWebsocketAck
                 .newBuilder()
                 .setType("ack")
                 .setId(id)
                 .build();
-        webSocket.sendBinary(serverInfo.toByteString().asReadOnlyByteBuffer(), true);
+        send(serverInfo.toByteString().asReadOnlyByteBuffer());
     }
 
-}
+
+
+    @Override
+    public void onMessage(String s) {
+
+    }
+}

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

@@ -0,0 +1,43 @@
+package io.github.jwdeveloper.tiktok;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import io.github.jwdeveloper.tiktok.common.TikTokBaseTest;
+import io.github.jwdeveloper.tiktok.messages.*;
+import org.junit.Test;
+
+public class ParseMessagesTests extends TikTokBaseTest
+{
+
+
+    @Test
+    public void ShouldParseMessageWebcastLikeMessage() throws InvalidProtocolBufferException {
+        var bytes = getFileBytesUtf("LikeMessage.bin");
+        var message = WebcastLikeMessage.parseFrom(bytes);
+    }
+
+    @Test
+    public void ShouldParseMessageWebcastGiftMessage() throws InvalidProtocolBufferException {
+        var bytes = getFileBytesUtf("MessageWebcastGiftMessage.bin");
+        var message = WebcastGiftMessage.parseFrom(bytes);
+    }
+    @Test
+    public void ShouldParseMessageWebcastChatMessage() throws InvalidProtocolBufferException {
+        var bytes = getFileBytesUtf("MessageWebcastChatMessage.bin");
+        var message = WebcastChatMessage.parseFrom(bytes);
+    }
+
+    @Test
+    public void ShouldParseMessageWebcastImDeleteMessage() throws InvalidProtocolBufferException {
+        var bytes = getFileBytesUtf("MessageWebcastImDeleteMessage.bin");
+        var message = WebcastImDeleteMessage.parseFrom(bytes);
+    }
+
+
+    @Test
+    public void ShouldParseMessageWebcastSocialMessage() throws InvalidProtocolBufferException {
+        var bytes = getFileBytesUtf("MessageWebcastSocialMessage.bin");
+        var message = WebcastSocialMessage.parseFrom(bytes);
+    }
+
+
+}

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

@@ -1,30 +0,0 @@
-package io.github.jwdeveloper.tiktok;
-
-import com.google.protobuf.InvalidProtocolBufferException;
-
-import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketMessage;
-import org.junit.Test;
-import java.io.IOException;
-
-public class SerializeWebMessageTest
-{
-    @Test
-    public void WebcastWebsocketMessage()
-    {
-        /*
-        try (var str = getClass().getClassLoader().getResourceAsStream("WebcastWebsocketMessage.bin"))
-        {
-            var bytes = str.readAllBytes();
-            var person = WebcastWebsocketMessage.parseFrom(bytes);
-            System.out.println("id: " + person.getId());
-            System.out.println("type: " + person.getType());
-            System.out.println("binary: " + person.getBinary().size());
-            // System.out.println("Email: " + person.getEmail());
-        } catch (InvalidProtocolBufferException e) {
-            System.out.println("Error parsing the protobuf message: " + e.getMessage());
-            e.printStackTrace();
-        } catch (IOException e) {
-            System.out.println("Error reading the file: " + e.getMessage());
-        }*/
-    }
-}

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

@@ -0,0 +1,26 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.tiktok.common.TikTokBaseTest;
+import io.github.jwdeveloper.tiktok.handlers.TikTokEventHandler;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
+import org.junit.Before;
+
+import java.util.logging.Logger;
+
+import static org.mockito.Mockito.mock;
+
+public class WebResponseHandlerTests extends TikTokBaseTest {
+    public static TikTokMessageHandlerRegistration sut;
+
+    @Before
+    public void before() {
+        var mockEventHandler = mock(TikTokEventHandler.class);
+        var mockGiftManager = mock(TikTokGiftManager.class);
+        var mockRoomInfo = mock(TikTokRoomInfo.class);
+        var mockClientSettings = mock(ClientSettings.class);
+        var mockLogger = mock(Logger.class);
+        sut = new TikTokMessageHandlerRegistration(mockEventHandler,mockClientSettings,mockLogger, mockGiftManager, mockRoomInfo);
+    }
+
+
+}

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

@@ -0,0 +1,34 @@
+package io.github.jwdeveloper.tiktok.common;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketMessage;
+
+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/resources/MessageWebcastImDeleteMessage.bin

@@ -0,0 +1 @@
+CjUKFldlYmNhc3RJbURlbGV0ZU1lc3NhZ2UQhZab+vyKvvJkGJKWhYz+o7DxZCC0sajzoTEwARoJhojH2ojIjaBk

Client/src/test/resources/MessageWebcastSocialMessage.bin

@@ -0,0 +1 @@
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

Client/src/test/resources/WebcastWebsocketMessage.bin

@@ -1,32 +0,0 @@
-	ŔĆł»›„ÖF¸E *
-
-compress_typenone2pb:msgBš
-Ű
-WebcastLikeMessageş
-
-WebcastLikeMessageˇ–¤ŚöÍííd –żÚřęëíd0
BŔ

-pm_mt_msg_viewer{0:user} liked the LIVE
-	#ffffffff "‚

-Ş
}
-{ ˆ”‚•ÉÔëdhulajnoga czek˛hulajnoga.czek5ňLMS4wLjABAAAAx4-lIrRjH0pMT0D3laROVsnU-4u6P1tN4td82AQTCHjKZ-CHaF_DluNSFQQp1s4DH
P
°
¸

Ŕ

 ĆĐ‚Ňź1†q*Ü ˆ”‚•ÉÔëdhulajnoga czek˛
ş
 ˛hulajnoga.czek5J˙
-Č
https://p16-sign-useast2a.tiktokcdn.com/tos-useast2a-avt-0068-euttp/26aa68e29831ff0c9d4fb37875efffdd~tplv-tiktok-shrink:72:72.webp?x-expires=1692291600&x-signature=Z2ZM2T%2FckIxKSj%2BJY%2BONoypyMwo%3D
-´
https://p16-sign-useast2a.tiktokcdn.com/tos-useast2a-avt-0068-euttp/26aa68e29831ff0c9d4fb37875efffdd~c5_100x100.webp?x-expires=1692291600&x-signature=gJgrVHIZWnVCif4Z6gXuhnl1pn8%3D
-´
https://p16-sign-useast2a.tiktokcdn.com/tos-useast2a-avt-0068-euttp/26aa68e29831ff0c9d4fb37875efffdd~c5_100x100.jpeg?x-expires=1692291600&x-signature=ITqTLj6v7UVl12HeeGa6a6FYNpc%3DD100x100/tos-useast2a-avt-0068-euttp/26aa68e29831ff0c9d4fb37875efffddŞ
0‚ ňLMS4wLjABAAAAx4-lIrRjH0pMT0D3laROVsnU-4u6P1tN4td82AQTCHjKZ-CHaF_DluNSFQQp1s4D‚îR„sslocal://webcast_webview_popup?gravity=bottom&show_mask=1&url=https%3A%2F%2Flf16-web.tiktokcdn.com%2Fobj%2Fies-hotsoon-draft-sg%2Ftiktok-live-faq%2Ftiktok_live_revenue_new_gifter_details.html&web_bg_color=FFFFFF&height=60%25&mask_bg_color=000000b3&use_spark=1b:"10000037267585271263611681*
0
-
27154120369731914523
1Ş
 pm_mt_live_ng_im
-New gifter( ‚Ü 
Résslocal://webcast_lynxview_popup?use_spark=1&url=https%3A%2F%2Flf16-gecko-source.tiktokcdn.com%2Fobj%2Fbyte-gurd-source-sg%2Ftiktok%2Ffe%2Flive%2Ftiktok_live_revenue_user_level_main%2Fsrc%2Fpages%2Fprivilege%2Fpanel%2Ftemplate.js&hide_status_bar=0&hide_nav_bar=1&container_bg_color=00000000&height=90%25&bdhm_bid=tiktok_live_revenue_user_level_main&use_forest=1X
bN
-
27138381176787457828
0".mock_fix_width_transparent_7138381176787457828*
2ş
’Ő+webcast-va/grade_badge_icon_lite_lv1_v1.png:ésslocal://webcast_lynxview_popup?use_spark=1&url=https%3A%2F%2Flf16-gecko-source.tiktokcdn.com%2Fobj%2Fbyte-gurd-source-sg%2Ftiktok%2Ffe%2Flive%2Ftiktok_live_revenue_user_level_main%2Fsrc%2Fpages%2Fprivilege%2Fpanel%2Ftemplate.js&hide_status_bar=0&hide_nav_bar=1&container_bg_color=00000000&height=90%25&bdhm_bid=tiktok_live_revenue_user_level_main&use_forest=1
-\https://p16-webcast.tiktokcdn.com/webcast-va/grade_badge_icon_lite_lv1_v1.png~tplv-obj.image
-\https://p19-webcast.tiktokcdn.com/webcast-va/grade_badge_icon_lite_lv1_v1.png~tplv-obj.image"
2* 
b
- 	#99789EE7x2 : " Z
- 	#99789EE7€
‚÷( R„sslocal://webcast_webview_popup?gravity=bottom&show_mask=1&url=https%3A%2F%2Flf16-web.tiktokcdn.com%2Fobj%2Fies-hotsoon-draft-sg%2Ftiktok-live-faq%2Ftiktok_live_revenue_new_gifter_details.html&web_bg_color=FFFFFF&height=60%25&mask_bg_color=000000b3&use_spark=1X
b:
-
27154120369731914523
1"10000037267585271263611681*
0ş
¦x€
ˆ
Ű 0:„sslocal://webcast_webview_popup?gravity=bottom&show_mask=1&url=https%3A%2F%2Flf16-web.tiktokcdn.com%2Fobj%2Fies-hotsoon-draft-sg%2Ftiktok-live-faq%2Ftiktok_live_revenue_new_gifter_details.html&web_bg_color=FFFFFF&height=60%25&mask_bg_color=000000b3&use_spark=1
-Shttps://p16-webcast.tiktokcdn.com/webcast-va/new_gifter_badge_v3.png~tplv-obj.image
-Shttps://p19-webcast.tiktokcdn.com/webcast-va/new_gifter_badge_v3.png~tplv-obj.image"webcast-va/new_gifter_badge_v3.png
-pm_mt_live_ng_im
-New gifterZ
- 	#803F3F3Fb
- 	#803F3F3FBÍ
†ˆË”Ź¨Á‚cŔ

-pm_mt_msg_viewer{0:user} liked the LIVE
-	#ffffffff "‚

-Ş
}
-{˛hulajnoga.czek5ňLMS4wLjABAAAAx4-lIrRjH0pMT0D3laROVsnU-4u6P1tN4td82AQTCHjKZ-CHaF_DluNSFQQp1s4D ˆ”‚•ÉÔëdhulajnoga czekH
ˇ–¤ŚöÍííd)1692120689751_7267603020139989890_1_1_0_0č  ×Ř‚Ňź1*
-@H

README.md

@@ -1,3 +1,6 @@
+[![](https://jitpack.io/v/jwdeveloper/TikTok-Live-Java.svg)](https://jitpack.io/#jwdeveloper/TikTok-Live-Java)
+
+
 # TikTok-Live-Java
 A Java library based on [TikTok-Connector](https://github.com/isaackogan/TikTok-Live-Connector) and [TikTokLiveSharp](https://github.com/sebheron/TikTokLiveSharp). Use it to receive live stream events such as comments and gifts in realtime from [TikTok LIVE](https://www.tiktok.com/live) by connecting to TikTok's internal WebCast push service. The package includes a wrapper that connects to the WebCast service using just the username (`uniqueId`). This allows you to connect to your own live chat as well as the live chat of other streamers. No credentials are required. Besides [Chat Comments](#chat), other events such as [Members Joining](#member), [Gifts](#gift), [Subscriptions](#subscribe), [Viewers](#roomuser), [Follows](#social), [Shares](#social), [Questions](#questionnew), [Likes](#like) and [Battles](#linkmicbattle) can be tracked. You can also send [automatic messages](#send-chat-messages) into the chat by providing your Session ID.
 
@@ -20,7 +23,7 @@ Do you prefer other programming languages?
 
 ## Getting started
 
-1. Install the package via Maven (dependecies will be simplify in future)
+1. Install the package via Maven 
 
 ```xml
    <repositories>
@@ -32,29 +35,28 @@ Do you prefer other programming languages?
 ```
 
 ```xml
-        <dependency>
+   <dependencies>
+         <dependency>
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java</artifactId>
             <version>3.24.1</version>
+            <scope>compile</scope>
         </dependency>
 
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
             <version>2.10.1</version>
+            <scope>compile</scope>
         </dependency>
 
         <dependency>
-            <groupId>com.github.jwdeveloper.TikTok-Live-Java</groupId>
-            <artifactId>API</artifactId>
-            <version>0.0.4-Release</version>
-        </dependency>
-
-        <dependency>
-            <groupId>com.github.jwdeveloper.TikTok-Live-Java</groupId>
-            <artifactId>Client</artifactId>
-            <version>0.0.4-Release</version>
+            <groupId>com.github.jwdeveloper</groupId>
+            <artifactId>TikTok-Live-Java</artifactId>
+            <version>0.0.12-Release</version>
+            <scope>compile</scope>
         </dependency>
+   </dependencies>
 ```
 
 2. Create your first chat connection
@@ -63,36 +65,69 @@ Do you prefer other programming languages?
   public static void main(String[] args)
   {
      // Username of someone who is currently live
-     var tiktokUsername = "officialgeilegisela";
+     var tiktokUsername = "jwdevtiktok";
 
      TikTokLive.newClient(tiktokUsername)
-                .onConnected(event ->
+                .onConnected((client, event) ->
                 {
                     System.out.println("Connected");
                 })
-                .onJoin(event ->
+                .onJoin((client, event)  ->
                 {
                     System.out.println("User joined -> " + event.getUser().getNickName());
                 })
-                .onComment(event ->
+                .onComment((client, event)  ->
                 {
-                    System.out.println(event.getUser().getUniqueId() + ": " + event.getText());
+                   System.out.println(event.getUser().getUniqueId() + ": " + event.getText());
                 })
-                .onError(event ->
+                .onEvent((client, event) ->
+                {
+                    System.out.println("Viewers count: "+client.getRoomInfo().getViewersCount());
+                })
+                .onError((client, event)  ->
                 {
                     event.getException().printStackTrace();
                 })
                 .buildAndRun();
+        System.in.read();
     }
 ```
+## Configuration
+
+```java
+public class ConfigurationExample
+{
+    public static void main(String[] args) throws IOException {
+       var tiktokUsername = "jwdevtiktok";
+       TikTokLive.newClient(tiktokUsername)
+                .configure(clientSettings ->
+                {
+                    clientSettings.setHostName(Main.TEST_TIKTOK_USER); // TikTok user name
+                    clientSettings.setClientLanguage("en"); // Language
+                    clientSettings.setTimeout(Duration.ofSeconds(2)); // Connection timeout
+                    clientSettings.setLogLevel(Level.ALL); // Log level
+                    clientSettings.setDownloadGiftInfo(true); // Downloading meta information about gifts. You can access it by client.getGiftManager().getGiftsInfo();
+                    clientSettings.setPrintMessageData(true); // Printing TikTok Protocol buffer messages in Base64 format
+                    clientSettings.setPrintToConsole(true); // Printing all logs to console even if log level is Level.OFF
+                    clientSettings.setHandleExistingMessagesOnConnect(true); // Invokes all TikTok events that had occurred before connection
+                    clientSettings.setRetryOnConnectionFailure(true); // Reconnecting if TikTok user is offline
+                    clientSettings.setRetryConnectionTimeout(Duration.ofSeconds(1)); // Timeout before next reconnection
+                })
+                .buildAndRun();
+       System.in.read();
+    }
+}
+
+```
 
 ## Methods
-A `TikTokLive` object contains the following methods.
+A `client (LiveClient)` object contains the following methods.
 
 | Method Name | Description |
 | ----------- | ----------- |
 | connect     | Connects to the live stream chat.<br>Returns a `Promise` which will be resolved when the connection is successfully established. |
 | disconnect  | Disconnects the connection. |
+| getGiftManager  |  Gets the meta informations about all gifts. |
 | getRoomInfo | Gets the current room info from TikTok API including streamer info, room status and statistics. |
 
 ## Events

TestApplication/pom.xml

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

TestApplication/src/main/java/io/github/jwdeveloper/tiktok/ConfigurationExample.java

@@ -0,0 +1,27 @@
+package io.github.jwdeveloper.tiktok;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.logging.Level;
+
+public class ConfigurationExample {
+    public static void main(String[] args) throws IOException {
+
+        TikTokLive.newClient(Main.TEST_TIKTOK_USER)
+                .configure(clientSettings ->
+                {
+                    clientSettings.setHostName(Main.TEST_TIKTOK_USER); // TikTok user name
+                    clientSettings.setClientLanguage("en"); // Language
+                    clientSettings.setTimeout(Duration.ofSeconds(2)); // Connection timeout
+                    clientSettings.setLogLevel(Level.ALL); // Log level
+                    clientSettings.setDownloadGiftInfo(true); // Downloading meta information about gifts. You can access it by client.getGiftManager().getGiftsInfo();
+                    clientSettings.setPrintMessageData(true); // Printing TikTok Protocol buffer messages in Base64 format
+                    clientSettings.setPrintToConsole(true); // Printing all logs to console even if log level is Level.OFF
+                    clientSettings.setHandleExistingMessagesOnConnect(true); // Invokes all TikTok events that had occurred before connection
+                    clientSettings.setRetryOnConnectionFailure(true); // Reconnecting if TikTok user is offline
+                    clientSettings.setRetryConnectionTimeout(Duration.ofSeconds(1)); // Timeout before next reconnection
+                })
+                .buildAndRun();
+        System.in.read();
+    }
+}

TestApplication/src/main/java/io/github/jwdeveloper/tiktok/Main.java

@@ -1,15 +1,16 @@
 package io.github.jwdeveloper.tiktok;
 
 import io.github.jwdeveloper.tiktok.events.messages.*;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
 
 import java.io.IOException;
 
 public class Main {
 
-    public static String TEST_USER_SUBJECT = "stiflerhub";
+    public static String TEST_TIKTOK_USER = "dmikl_";
 
     public static void main(String[] args) throws IOException {
-        var client = TikTokLive.newClient(TEST_USER_SUBJECT)
+        var client = TikTokLive.newClient(TEST_TIKTOK_USER)
                 .onConnected(Main::onConnected)
                 .onDisconnected(Main::onDisconnected)
                 .onRoomViewerData(Main::onViewerData)
@@ -21,60 +22,59 @@ public class Main {
                 .onLike(Main::onLike)
                 .onGiftMessage(Main::onGiftMessage)
                 .onEmote(Main::onEmote)
-                .onError(tikTokErrorEvent ->
+                .onError((_client, error) ->
                 {
-                  //  tikTokErrorEvent.getException().printStackTrace();
+                    error.getException().printStackTrace();
                 })
                 .buildAndRun();
 
-
         var viewers = client.getRoomInfo().getViewersCount();
         System.in.read();
     }
 
-    private static void onConnected(TikTokConnectedEvent e) {
+    private static void onConnected(LiveClient tikTokLive, TikTokConnectedEvent e) {
         print("Connected");
     }
 
-    private static void onDisconnected(TikTokDisconnectedEvent e) {
+    private static void onDisconnected(LiveClient tikTokLive, TikTokDisconnectedEvent e) {
         print("Disconnected");
     }
 
-    private static void onViewerData(TikTokRoomViewerDataEvent e) {
+    private static void onViewerData(LiveClient tikTokLive, TikTokRoomViewerDataEvent e) {
         print("Viewer count is:", e.getViewerCount());
     }
 
-    private static void onJoin(TikTokJoinEvent e) {
+    private static void onJoin(LiveClient tikTokLive, TikTokJoinEvent e) {
         print(e.getUser().getUniqueId(), "joined!");
     }
 
-    private static void onComment(TikTokCommentEvent e) {
-        print("DUPA: "+e.getText());
-       // print(e.getUser().getUniqueId(), e.getText());
+    private static void onComment(LiveClient tikTokLive, TikTokCommentEvent e) {
+        print(e.getUser().getUniqueId(), e.getText());
     }
 
-    private static void onFollow(TikTokFollowEvent e) {
+    private static void onFollow(LiveClient tikTokLive, TikTokFollowEvent e) {
         print(e.getNewFollower().getUniqueId(), "followed!");
     }
 
-    private static void onShare(TikTokShareEvent e) {
+    private static void onShare(LiveClient tikTokLive, TikTokShareEvent e) {
         print(e.getUser().getUniqueId(), "shared!");
     }
 
-    private static void onSubscribe(TikTokSubscribeEvent e) {
+    private static void onSubscribe(LiveClient tikTokLive, TikTokSubscribeEvent e) {
         print(e.getNewSubscriber().getUniqueId(), "subscribed!");
     }
 
-    private static void onLike(TikTokLikeEvent e) {
+    private static void onLike(LiveClient tikTokLive, TikTokLikeEvent e) {
 
         print(e.getSender().getUniqueId(), "liked!");
     }
 
-    private static void onGiftMessage(TikTokGiftMessageEvent e) {
+    private static void onGiftMessage(LiveClient tikTokLive, TikTokGiftMessageEvent e)
+    {
         print(e.getSender().getUniqueId(), "sent", e.getAmount(), "x", e.getGift().getName());
     }
 
-    private static void onEmote(TikTokEmoteEvent e) {
+    private static void onEmote(LiveClient tikTokLive, TikTokEmoteEvent e) {
         print(e.getUser().getUniqueId(), "sent", e.getEmoteId());
     }
 
@@ -83,6 +83,6 @@ public class Main {
         for (var message : messages) {
             sb.append(message).append(" ");
         }
-        System.out.println(sb.toString());
+        System.out.println(sb);
     }
 }

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

@@ -1,30 +1,32 @@
 package io.github.jwdeveloper.tiktok;
 
-public class SimpleExample {
-    public static void main(String[] args) {
-        // Username of someone who is currently live
-        var tiktokUsername = "officialgeilegisela";
+import java.io.IOException;
 
-        TikTokLive.newClient(tiktokUsername)
-                .clientSettings(settings ->
-                {
-                })
-                .onConnected(event ->
+public class SimpleExample {
+    public static void main(String[] args) throws IOException {
+
+        TikTokLive.newClient(Main.TEST_TIKTOK_USER)
+                .onConnected((client, event) ->
                 {
                     System.out.println("Connected");
                 })
-                .onJoin(event ->
+                .onJoin((client, event)  ->
                 {
                     System.out.println("User joined -> " + event.getUser().getNickName());
                 })
-                .onComment(event ->
+                .onComment((client, event)  ->
                 {
-                    System.out.println(event.getUser().getUniqueId() + ": " + event.getText());
+                   System.out.println(event.getUser().getUniqueId() + ": " + event.getText());
                 })
-                .onError(event ->
+                .onEvent((client, event) ->
+                {
+                    System.out.println("Viewers count: "+client.getRoomInfo().getViewersCount());
+                })
+                .onError((client, event)  ->
                 {
                     event.getException().printStackTrace();
                 })
                 .buildAndRun();
+        System.in.read();
     }
 }

Tools/pom.xml

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

Tools/src/main/java/io/github/jwdeveloper/tiktok/events_generator/EventsGenerator.java

@@ -1,12 +1,9 @@
 package io.github.jwdeveloper.tiktok.events_generator;
 
-import io.github.jwdeveloper.tiktok.FilesUtility;
+import io.github.jwdeveloper.tiktok.utils.FilesUtility;
 
 import java.io.File;
 import java.io.IOException;
-import java.nio.file.Files;
-import java.util.ArrayList;
-import java.util.List;
 
 public class EventsGenerator
 {

Tools/src/main/java/io/github/jwdeveloper/tiktok/intefacee/EventsInterfaceGenerator.java

@@ -20,16 +20,16 @@ public class EventsInterfaceGenerator {
             //   System.out.println(clazz.getName());
         }
 
-     //var result = generateInterface("io.github.jwdeveloper.tiktok.events", classes);System.out.println(result);
+    // var result = generateInterface("io.github.jwdeveloper.tiktok.events", classes);System.out.println(result);
 
 
-      var result =  getBuilderImplementation("x",classes); System.out.println(result);
+     var result =  getBuilderImplementation("x",classes); System.out.println(result);
 
     }
 
     public String generateInterface(String packageName, Set<Class<? extends TikTokEvent>> eventsClasses) {
 
-        TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder("TikTokEvents");
+        TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder("TikTokEventBuilder");
         classBuilder.addModifiers(Modifier.PUBLIC);
         classBuilder.addTypeVariable(TypeVariableName.get("T"));
 
@@ -46,7 +46,7 @@ public class EventsInterfaceGenerator {
             MethodSpec.Builder constructorBuilder = MethodSpec.methodBuilder("on" + methodName);
 
 
-            var name = "Consumer<" + clazzName + ">";
+            var name = "TikTokEventConsumer<" + clazzName + ">";
             constructorBuilder.addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC);
             constructorBuilder.addParameter(ClassName.bestGuess(name), "event");
             constructorBuilder.returns(TypeVariableName.get("T"));
@@ -91,7 +91,7 @@ public class EventsInterfaceGenerator {
             MethodSpec.Builder constructorBuilder = MethodSpec.methodBuilder( methodName);
 
 
-            var name = "Consumer<" + clazzName + ">";
+            var name = "TikTokEventConsumer<" + clazzName + ">";
             constructorBuilder.addModifiers( Modifier.PUBLIC);
             constructorBuilder.addParameter(ClassName.bestGuess(name), "event");
             constructorBuilder.addStatement("tikTokEventHandler.subscribe("+clazzName+".class,event)");

Tools/src/main/java/io/github/jwdeveloper/tiktok/utils/FilesUtility.java

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok;
+package io.github.jwdeveloper.tiktok.utils;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;

pom.xml

@@ -7,7 +7,7 @@
     <groupId>io.github.jwdeveloper.tiktok</groupId>
     <artifactId>TikTokLiveJava</artifactId>
     <packaging>pom</packaging>
-    <version>1.0.0</version>
+    <version>0.0.12-Release</version>
     <modules>
         <module>API</module>
         <module>Client</module>
@@ -54,6 +54,7 @@
                         <configuration>
                             <shadedArtifactAttached>true</shadedArtifactAttached>
                             <shadedClassifierName>all</shadedClassifierName>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
                             <minimizeJar>true</minimizeJar>
                             <artifactSet>
                                 <includes>
@@ -64,8 +65,6 @@
                                 <filter>
                                     <artifact>*:*</artifact>
                                     <excludes>
-                                        <exclude>**/proto/**</exclude>
-                                        <exclude>**/google/**</exclude>
                                         <exclude>**/tiktokSchema.proto/**</exclude>
                                     </excludes>
                                 </filter>
@@ -99,6 +98,8 @@
             <scope>test</scope>
         </dependency>
 
+
+
     </dependencies>
 
 </project>