Events handling

API/pom.xml

@@ -4,7 +4,7 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
-        <groupId>org.example</groupId>
+        <groupId>io.github.jwdeveloper.tiktok</groupId>
         <version>1.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
@@ -17,6 +17,24 @@
             <version>1.18.22</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>RELEASE</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+            <version>3.8.0</version>
+        </dependency>
     </dependencies>
 
     <properties>
@@ -25,4 +43,52 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
+    <build>
+        <sourceDirectory>target/generated-sources</sourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>kr.motd.maven</groupId>
+                <artifactId>os-maven-plugin</artifactId>
+                <version>1.7.0</version>
+                <executions>
+                    <execution>
+                        <phase>initialize</phase>
+                        <goals>
+                            <goal>detect</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+
+            <plugin>
+                <groupId>com.github.os72</groupId>
+                <artifactId>protoc-jar-maven-plugin</artifactId>
+                <version>3.11.4</version>
+                <executions>
+                    <execution>
+                        <phase>generate-sources</phase>
+                        <goals>
+                            <goal>run</goal>
+                        </goals>
+                        <configuration>
+                            <addProtoSources>all</addProtoSources>
+                            <includeMavenTypes>direct</includeMavenTypes>
+                            <includeDirectories>
+                                <include>src/main</include>
+                            </includeDirectories>
+                            <inputDirectories>
+                                <include>src/main/proto</include>
+                            </inputDirectories>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <!-- Add other plugins as needed -->
+        </plugins>
+    </build>
+
+
+
 </project>

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

@@ -0,0 +1,4 @@
+package io.github.jwdeveloper.tiktok.annotations;
+
+public @interface Nullable {
+}

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

@@ -0,0 +1,41 @@
+package io.github.jwdeveloper.tiktok.events;
+
+import io.github.jwdeveloper.tiktok.messages.*;
+import lombok.Getter;
+
+@Getter
+public class TikTokEvent {
+    private long messageId;
+    private long roomId;
+    private long timeStamp;
+
+    public TikTokEvent(MessageHeader header) {
+        this(header.getMessageId(),header.getRoomId(), header.getTimeStamp1());
+    }
+
+    public TikTokEvent(GiftMessageHeader header) {
+        this(header.getMessageId(),header.getRoomId(), header.getTimeStamp1());
+    }
+
+    public TikTokEvent(MemberMessageHeader header) {
+        this(header.getMessageId(),header.getRoomId(), header.getTimeStamp1());
+    }
+
+    public TikTokEvent(SocialMessageHeader header) {
+        this(header.getMessageId(),header.getRoomId(), header.getTimeStamp1());
+    }
+
+    public TikTokEvent(LikeMessageHeader header) {
+        this(header.getMessageId(),header.getRoomId(), header.getTimeStamp1());
+    }
+
+    public TikTokEvent(long messageId, long roomId, long timeStamp) {
+        this.messageId = messageId;
+        this.roomId = roomId;
+        this.timeStamp = timeStamp;
+    }
+
+    public TikTokEvent() {
+
+    }
+}

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

@@ -0,0 +1,75 @@
+package io.github.jwdeveloper.tiktok.events;
+
+import io.github.jwdeveloper.tiktok.events.messages.*;
+
+import java.util.function.Consumer;
+
+
+
+public interface TikTokEventBuilder<T> {
+    T onLinkMicFanTicket(Consumer<TikTokLinkMicFanTicketEvent> event);
+
+    T onEnvelope(Consumer<TikTokEnvelopeEvent> event);
+
+    T onShopMessage(Consumer<TikTokShopMessageEvent> event);
+
+    T onDetectMessage(Consumer<TikTokDetectMessageEvent> event);
+
+    T onLinkLayerMessage(Consumer<TikTokLinkLayerMessageEvent> event);
+
+    T onCaption(Consumer<TikTokCaptionEvent> event);
+
+    T onQuestion(Consumer<TikTokQuestionEvent> event);
+
+    T onRoomPinMessage(Consumer<TikTokRoomPinMessageEvent> event);
+
+    T onRoomMessage(Consumer<TikTokRoomMessageEvent> event);
+
+    T onLike(Consumer<TikTokLikeEvent> event);
+
+    T onLinkMessage(Consumer<TikTokLinkMessageEvent> event);
+
+    T onBarrageMessage(Consumer<TikTokBarrageMessageEvent> event);
+
+    T onGiftMessage(Consumer<TikTokGiftMessageEvent> event);
+
+    T onLinkMicArmies(Consumer<TikTokLinkMicArmiesEvent> event);
+
+    T onEmote(Consumer<TikTokEmoteEvent> event);
+
+    T onUnauthorizedMember(Consumer<TikTokUnauthorizedMemberEvent> event);
+
+    T onInRoomBanner(Consumer<TikTokInRoomBannerEvent> event);
+
+    T onLinkMicMethod(Consumer<TikTokLinkMicMethodEvent> event);
+
+    T onSubscribe(Consumer<TikTokSubscribeEvent> event);
+
+    T onPollMessage(Consumer<TikTokPollMessageEvent> event);
+
+    T onFollow(Consumer<TikTokFollowEvent> event);
+
+    T onRoomViewerData(Consumer<TikTokRoomViewerDataEvent> event);
+
+    T onGoalUpdate(Consumer<TikTokGoalUpdateEvent> event);
+
+    T onComment(Consumer<TikTokCommentEvent> event);
+
+    T onRankUpdate(Consumer<TikTokRankUpdateEvent> event);
+
+    T onIMDelete(Consumer<TikTokIMDeleteEvent> event);
+
+    T onJoin(Consumer<TikTokJoinEvent> event);
+
+    T onRankText(Consumer<TikTokRankTextEvent> event);
+
+    T onShare(Consumer<TikTokShareEvent> event);
+
+    T onSubNotify(Consumer<TikTokSubNotifyEvent> event);
+
+    T onLinkMicBattle(Consumer<TikTokLinkMicBattleEvent> event);
+
+    T onGiftBroadcast(Consumer<TikTokGiftBroadcastEvent> event);
+}
+
+

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

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

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

@@ -0,0 +1,37 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.BarrageData;
+import io.github.jwdeveloper.tiktok.events.objects.Picture;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastBarrageMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokBarrageMessageEvent extends TikTokEvent {
+    private final Picture picture;
+
+    private final Picture picture2;
+
+    private final Picture picture3;
+
+    private final User user;
+    private final BarrageData barrageData;
+
+    public TikTokBarrageMessageEvent(WebcastBarrageMessage msg) {
+        super(msg.getHeader());
+
+        picture = new Picture(msg.getPicture());
+        picture2 = new Picture(msg.getPicture2());
+        picture3 = new Picture(msg.getPicture3());
+        user = new User(msg.getUserData().getUser());
+        barrageData = new BarrageData(msg.getMessage().getEventType(),
+                msg.getMessage().getLabel(),
+                msg.getMessage().getData1List().stream().map(e ->
+                {
+                    var user = new User(e.getUser().getUser());
+                    return new BarrageData.BarrageUser(user, e.getData2());
+                }).toList()
+        );
+    }
+}

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

@@ -0,0 +1,21 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastCaptionMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokCaptionEvent extends TikTokEvent {
+    private final Long captionTimeStamp;
+
+    private final String iSOLanguage;
+
+    private final String text;
+
+    public TikTokCaptionEvent(WebcastCaptionMessage msg) {
+        super(msg.getHeader());
+        captionTimeStamp = msg.getTimeStamp();
+        iSOLanguage = msg.getCaptionData().getISOLanguage();
+        text = msg.getCaptionData().getText();
+    }
+}

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

@@ -0,0 +1,43 @@
+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.Picture;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastChatMessage;
+import io.github.jwdeveloper.tiktok.messages.WebcastRoomPinMessage;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+public class TikTokCommentEvent extends TikTokEvent
+{
+    @Nullable
+    private User user;
+    private final String text;
+    private final String language;
+    private final List<User> mentionedUsers;
+    private final List<Picture> pictures;
+
+    public TikTokCommentEvent(WebcastRoomPinMessage.RoomPinMessageData data) {
+        super(data.getDetails().getRoomId(), data.getDetails().getMessageId(), data.getDetails().getServerTime());
+        if (data.hasSender())
+            user = new User(data.getSender());
+        text = data.getComment();
+        language = data.getLanguage();
+        mentionedUsers = new ArrayList<>();
+        pictures = new ArrayList<>();
+    }
+
+    public TikTokCommentEvent(WebcastChatMessage msg) {
+        super(msg.getHeader());
+        if (msg.hasSender())
+            user = new User(msg.getSender());
+        text = msg.getComment();
+        language = msg.getLanguage();
+        mentionedUsers = msg.getMentionedUsersList().stream().map(User::new).toList();
+        pictures = msg.getImagesList().stream().map(e -> new Picture(e.getPicture())).toList();
+    }
+}

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

@@ -0,0 +1,8 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+
+public class TikTokConnectedEvent extends TikTokEvent
+{
+
+}

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

@@ -0,0 +1,23 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastMsgDetectMessage;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokDetectMessageEvent extends TikTokEvent {
+  private final String language;
+
+  private final List<Number> data;
+
+  private final List<Number> timings;
+
+  public TikTokDetectMessageEvent(WebcastMsgDetectMessage msg) {
+    super(msg.getHeader());;
+    language = msg.getLanguage();
+    data = List.of(msg.getData2().getData1(), msg.getData2().getData2(), msg.getData2().getData3());
+    timings= List.of(msg.getTimestamps().getTimestamp1(), msg.getTimestamps().getTimestamp2(), msg.getTimestamps().getTimestamp3());
+  }
+}

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

@@ -0,0 +1,6 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+
+public class TikTokDisconnectedEvent extends TikTokEvent {
+}

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

@@ -0,0 +1,26 @@
+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.Picture;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastEmoteChatMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokEmoteEvent extends TikTokEvent
+{
+    @Nullable
+    private User user;
+    private final String emoteId;
+    private final Picture picture;
+
+    public TikTokEmoteEvent(WebcastEmoteChatMessage msg) {
+        super(msg.getHeader());
+        if (msg.hasSender()) {
+            user = new User(msg.getSender());
+        }
+        emoteId = msg.getDetails().getId();
+        picture = new Picture(msg.getDetails().getImage().getUrl());
+    }
+}

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

@@ -0,0 +1,16 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastEnvelopeMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokEnvelopeEvent extends TikTokEvent {
+  private final User user;
+
+  public TikTokEnvelopeEvent(WebcastEnvelopeMessage msg) {
+    super(msg.getHeader());
+    user = new User(msg.getUser().getId(), msg.getUser().getUsername());
+  }
+}

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

@@ -0,0 +1,25 @@
+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.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastSocialMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokFollowEvent extends TikTokEvent
+{
+  @Nullable
+  private User newFollower;
+  private final Long totalFollowers;
+
+  public TikTokFollowEvent(WebcastSocialMessage msg) {
+    super(msg.getHeader());
+    if(msg.hasSender())
+    {
+      newFollower = new User(msg.getSender());
+    }
+    totalFollowers = msg.getTotalFollowers();
+
+  }
+}

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

@@ -0,0 +1,31 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.Picture;
+import io.github.jwdeveloper.tiktok.messages.WebcastGiftBroadcastMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokGiftBroadcastEvent extends TikTokEvent
+{
+  private final Picture picture;
+
+  private final String shortURL;
+
+  private final String notifyEventType;
+
+  private final String notifyLabel;
+
+  private final String notifyType;
+
+  public TikTokGiftBroadcastEvent(WebcastGiftBroadcastMessage msg)
+  {
+    super(msg.getHeader());
+    picture = new Picture(msg.getPicture());
+    var data = msg.getData();
+    shortURL = data.getUri();
+    notifyEventType = data.getRoomNotifyMessage().getData().getType();
+    notifyLabel = data.getRoomNotifyMessage().getData().getLabel();
+    notifyType = data.getNotifyType();
+  }
+}

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

@@ -0,0 +1,40 @@
+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.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 String purchaseId;
+
+  private final String receipt;
+
+  private final Integer amount;
+
+  private final  Boolean streakFinished;
+
+  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();
+  }
+}

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

@@ -0,0 +1,29 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.Picture;
+
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastGoalUpdateMessage;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokGoalUpdateEvent extends TikTokEvent
+{
+  private final Long goalId;
+  private final Picture picture;
+  private final String eventType;
+  private final String label;
+  private final List<User> users;
+
+  public TikTokGoalUpdateEvent(WebcastGoalUpdateMessage msg) {
+    super(msg.getHeader());
+    picture = new Picture(msg.getPicture());
+    goalId = msg.getId();
+    eventType = msg.getData().getType();
+    label = msg.getUpdateData().getLabel();
+    users = msg.getUpdateData().getUsersList().stream().map(u ->new User(u.getId(),u.getNickname(),new Picture(u.getProfilePicture()))).toList();
+  }
+}

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

@@ -0,0 +1,17 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastImDeleteMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokIMDeleteEvent extends TikTokEvent {
+  private final String data1;
+  private final String data2;
+
+  public TikTokIMDeleteEvent(WebcastImDeleteMessage msg) {
+    super(msg.getHeader());;
+    data1 = msg.getData1();
+    data2 = msg.getData2();
+  }
+}

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

@@ -0,0 +1,15 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastInRoomBannerMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokInRoomBannerEvent extends TikTokEvent {
+  private String jSON;
+
+  public TikTokInRoomBannerEvent(WebcastInRoomBannerMessage msg) {
+    super(msg.getHeader());;
+    jSON = msg.getJson();
+  }
+}

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

@@ -0,0 +1,34 @@
+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.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastMemberMessage;
+import io.github.jwdeveloper.tiktok.messages.WebcastSocialMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokJoinEvent extends TikTokEvent {
+    @Nullable
+    private User user;
+
+    private final Long totalViewers;
+
+    public TikTokJoinEvent(WebcastSocialMessage msg) {
+        super(msg.getHeader());
+
+        if (msg.hasSender()) {
+            user = new User(msg.getSender());
+        }
+
+        totalViewers = 0L;
+    }
+
+    public TikTokJoinEvent(WebcastMemberMessage msg) {
+        super(msg.getHeader());
+        if (msg.hasUser()) {
+            user = new User(msg.getUser());
+        }
+        totalViewers = msg.getTotalViewers();
+    }
+}

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

@@ -0,0 +1,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.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastLikeMessage;
+import io.github.jwdeveloper.tiktok.messages.WebcastSocialMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokLikeEvent extends TikTokEvent
+{
+    @Nullable
+    private User sender;
+
+    private final Integer count;
+
+    private final Long totalLikes;
+
+    public TikTokLikeEvent(WebcastSocialMessage msg) {
+        super(msg.getHeader());
+        if (msg.hasSender()) {
+            sender = new User(msg.getSender());
+        }
+        count = 1;
+        totalLikes = 0L;
+    }
+
+    public TikTokLikeEvent(WebcastLikeMessage msg) {
+        super(msg.getHeader());
+
+        if (msg.hasSender()) {
+            sender = new User(msg.getSender());
+        }
+
+        count = msg.getCount();
+        totalLikes = msg.getTotalLikes();
+    }
+}

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

@@ -0,0 +1,27 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkLayerMessage;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+public class TikTokLinkLayerMessageEvent extends TikTokEvent {
+    private final Long linkId;
+    private final LinkData link1;
+    private final LinkData link2;
+
+    public TikTokLinkLayerMessageEvent(WebcastLinkLayerMessage msg) {
+        super(msg.getHeader());
+        linkId = msg.getId();
+        link1 = new LinkData(msg.getIdContainer1().getIds().getId1(), msg.getIdContainer1().getIds().getId2());
+        link2 = new LinkData(msg.getIdContainer2().getIds().getId1(), msg.getIdContainer2().getIds().getId2());
+    }
+
+    @AllArgsConstructor
+    @Getter
+    private class LinkData {
+        private final Long id1;
+        private final Long id2;
+    }
+}

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

@@ -0,0 +1,28 @@
+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.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkMessage;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokLinkMessageEvent extends TikTokEvent {
+    private final String token;
+
+    @Nullable
+    private User user;
+
+    private final List<User> otherUsers;
+
+    public TikTokLinkMessageEvent(WebcastLinkMessage msg) {
+        super(msg.getHeader());
+        token = msg.getToken();
+        if (msg.getUser().getUser().hasUser()) {
+            user = new User(msg.getUser().getUser().getUser());
+        }
+        otherUsers = msg.getUser().getOtherUsersList().stream().map(e -> new User(e.getUser())).toList();
+    }
+}

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

@@ -0,0 +1,28 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.LinkMicArmy;
+import io.github.jwdeveloper.tiktok.events.objects.Picture;
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkMicArmies;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokLinkMicArmiesEvent extends TikTokEvent {
+    private final Long battleId;
+
+    private final Integer battleStatus;
+
+    private final Picture picture;
+
+    private final List<LinkMicArmy> armies;
+
+    public TikTokLinkMicArmiesEvent(WebcastLinkMicArmies msg) {
+        super(msg.getHeader());
+        battleId = msg.getId();
+        armies = msg.getBattleItemsList().stream().map(LinkMicArmy::new).toList();
+        picture = new Picture(msg.getPicture());
+        battleStatus = msg.getBattleStatus();
+    }
+}

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

@@ -0,0 +1,22 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.LinkMicBattleTeam;
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkMicBattle;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokLinkMicBattleEvent extends TikTokEvent {
+  private final Long battleId;
+  private final List<LinkMicBattleTeam> team1;
+  private final List<LinkMicBattleTeam> team2;
+
+  public TikTokLinkMicBattleEvent(WebcastLinkMicBattle msg) {
+    super(msg.getHeader());
+    battleId = msg.getId();
+    team1 = msg.getTeams1List().stream().map(LinkMicBattleTeam::new).toList();
+    team2 = msg.getTeams2List().stream().map(LinkMicBattleTeam::new).toList();
+  }
+}

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

@@ -0,0 +1,19 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkMicFanTicketMethod;
+import lombok.Getter;
+
+@Getter
+public class TikTokLinkMicFanTicketEvent extends TikTokEvent {
+    private final Long id;
+    private final Integer data1;
+    private final Integer data2;
+
+    public TikTokLinkMicFanTicketEvent(WebcastLinkMicFanTicketMethod msg) {
+        super(msg.getHeader());
+        id = msg.getData().getDetails().getId();
+        data1 = msg.getData().getData1();
+        data2 = msg.getData().getDetails().getData();
+    }
+}

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

@@ -0,0 +1,21 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.LinkMicMethod;
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkMicMethod;
+import lombok.Getter;
+
+@Getter
+public class TikTokLinkMicMethodEvent extends TikTokEvent {
+  private final String jSON;
+
+  public TikTokLinkMicMethodEvent(WebcastLinkMicMethod msg) {
+    super(msg.getHeader());;
+    jSON = "";
+  }
+
+  public TikTokLinkMicMethodEvent(LinkMicMethod msg) {
+    super(msg.getHeader());;
+    jSON = msg.getJson();
+  }
+}

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

@@ -0,0 +1,6 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+
+public class TikTokLiveEndedEvent extends TikTokEvent {
+}

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

@@ -0,0 +1,6 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+
+public class TikTokLivePausedEvent extends TikTokEvent {
+}

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

@@ -0,0 +1,28 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.PollOption;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastPollMessage;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokPollMessageEvent extends TikTokEvent {
+    private final Long id;
+
+    private final PollOption option1;
+
+    private final PollOption option2;
+
+    private final List<PollOption.Option> options;
+
+    public TikTokPollMessageEvent(WebcastPollMessage msg) {
+        super(msg.getHeader());
+        id = msg.getId();
+        options = msg.getPollData().getOptionsList().stream().map(e -> new PollOption.Option(e.getLabel(), e.getCurrentTotal())).toList();
+        option1 = new PollOption(new User(msg.getOptions1().getUser()), msg.getOptions1().getOptionsList().stream().map(e -> new PollOption.Option(e.getLabel(), e.getCurrentTotal())).toList());
+        option2 = new PollOption(new User(msg.getOptions2().getUser()), msg.getOptions2().getOptionsList().stream().map(e -> new PollOption.Option(e.getLabel(), e.getCurrentTotal())).toList());
+    }
+}

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

@@ -0,0 +1,29 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastQuestionNewMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokQuestionEvent extends TikTokEvent {
+    private final Long questionId;
+
+    private final String text;
+
+    private final Long time;
+
+    private User user;
+
+
+    public TikTokQuestionEvent(WebcastQuestionNewMessage msg) {
+        super(msg.getHeader());
+        var data = msg.getDetails();
+        questionId = data.getId();
+        text = data.getText();
+        time = data.getTimeStamp();
+        if (data.hasUser()) {
+            user = new User(data.getUser());
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastRankTextMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokRankTextEvent extends TikTokEvent {
+  private String eventType;
+
+  private String label;
+
+
+  public TikTokRankTextEvent(WebcastRankTextMessage msg) {
+    super(0,0,0);//TODO passing info
+    eventType = msg.getDetails().getType();
+    label =msg.getDetails().getLabel();
+  }
+
+}

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

@@ -0,0 +1,38 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastHourlyRankMessage;
+import io.github.jwdeveloper.tiktok.messages.WebcastRankUpdateMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokRankUpdateEvent extends TikTokEvent {
+  private final String eventType;
+
+  private final String label;
+
+  private final String rank;
+
+  private final String color;
+
+  public TikTokRankUpdateEvent(WebcastHourlyRankMessage msg) {
+    super(msg.getHeader());
+    var rankData = msg.getData().getRankings();
+    eventType = rankData.getType();
+    label = rankData.getLabel();
+    rank = rankData.getDetails(0).getLabel();
+    color = rankData.getColor().getColor();
+
+
+  }
+
+  public TikTokRankUpdateEvent(WebcastRankUpdateMessage msg) {
+    super(msg.getHeader());
+    var rankData = msg.getData().getRankData();
+    eventType = rankData.getType();
+    label = rankData.getLabel();
+    rank = rankData.getDetails(0).getLabel();
+    color = rankData.getColor().getColor();
+  }
+
+}

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

@@ -0,0 +1,44 @@
+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.User;
+import io.github.jwdeveloper.tiktok.messages.RoomMessage;
+import io.github.jwdeveloper.tiktok.messages.SystemMessage;
+import io.github.jwdeveloper.tiktok.messages.WebcastLiveIntroMessage;
+import io.github.jwdeveloper.tiktok.messages.WebcastRoomMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokRoomMessageEvent extends TikTokEvent {
+    @Nullable
+    private User host;
+    @Nullable
+    private String hostLanguage;
+    private final String message;
+
+    public TikTokRoomMessageEvent(WebcastRoomMessage msg) {
+        super(msg.getHeader());
+        message = msg.getData();
+    }
+
+    public TikTokRoomMessageEvent(SystemMessage msg) {
+        super(msg.getHeader());
+        message = msg.getMessage();
+    }
+
+    public TikTokRoomMessageEvent(RoomMessage msg) {
+        super(msg.getHeader());
+        message = msg.getMessage();
+    }
+
+    public TikTokRoomMessageEvent(WebcastLiveIntroMessage msg) {
+        super(msg.getHeader());
+        if (msg.hasHost()) {
+            host = new User(msg.getHost());
+        }
+        message = msg.getDescription();
+        hostLanguage = msg.getLanguage();
+    }
+
+}

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

@@ -0,0 +1,18 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastRoomPinMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokRoomPinMessageEvent extends TikTokEvent {
+  private final Long pinTimeStamp;
+  private final TikTokCommentEvent comment;
+
+  public TikTokRoomPinMessageEvent(WebcastRoomPinMessage msg) {
+    super(msg.getHeader());
+    this.pinTimeStamp = msg.getTimestamp();
+    this.comment = new TikTokCommentEvent(msg.getPinData1());
+  }
+
+}

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

@@ -0,0 +1,23 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.TopViewer;
+import io.github.jwdeveloper.tiktok.messages.WebcastRoomUserSeqMessage;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class TikTokRoomViewerDataEvent extends TikTokEvent {
+  private final Integer viewerCount;
+  private final List<TopViewer> topViewers;
+
+  public TikTokRoomViewerDataEvent(WebcastRoomUserSeqMessage msg) {
+    super(msg.getHeader());
+
+    //TODO sorting by rank       TopViewers = msg?.TopViewers?.Select(t => new Objects.TopViewer(t))?.OrderBy(t => t.Rank)?
+    viewerCount = msg.getViewerCount();
+    topViewers = msg.getTopViewersList().stream().map(TopViewer::new).toList();
+  }
+
+}

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

@@ -0,0 +1,32 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastSocialMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokShareEvent extends TikTokEvent {
+  private User user;
+
+  private Integer amount;
+
+  public TikTokShareEvent(WebcastSocialMessage msg, Integer amount) {
+    super(msg.getHeader());;
+    if(msg.hasSender())
+    {
+      user = new User(msg.getSender());
+    }
+    this.amount = amount;
+  }
+
+  public TikTokShareEvent(WebcastSocialMessage msg) {
+    super(msg.getHeader());
+    if(msg.hasSender())
+    {
+      user = new User(msg.getSender());
+    }
+    amount = 1;
+  }
+
+}

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

@@ -0,0 +1,30 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.Picture;
+import io.github.jwdeveloper.tiktok.messages.WebcastOecLiveShoppingMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokShopMessageEvent extends TikTokEvent {
+  private final String title;
+
+  private final String price;
+
+  private final Picture picture;
+
+  private final String shopUrl;
+
+  private final String shopName;
+
+  public TikTokShopMessageEvent(WebcastOecLiveShoppingMessage msg) {
+    super(msg.getHeader());
+    var data = msg.getShopData();
+    title = data.getTitle();
+    price = data.getPriceString();
+    picture = new Picture(data.getImageUrl());
+    shopUrl = data.getShopUrl();
+    shopName = data.getShopName();
+  }
+
+}

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

@@ -0,0 +1,21 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastSubNotifyMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokSubNotifyEvent extends TikTokEvent {
+    private User user;
+
+    public TikTokSubNotifyEvent(WebcastSubNotifyMessage msg) {
+        super(msg.getHeader());
+
+        if (msg.hasSender()) {
+            user = new User(msg.getSender());
+        }
+
+    }
+
+}

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

@@ -0,0 +1,21 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.objects.User;
+import io.github.jwdeveloper.tiktok.messages.WebcastMemberMessage;
+import lombok.Getter;
+
+@Getter
+public class TikTokSubscribeEvent extends TikTokEvent {
+  private User newSubscriber;
+
+  public TikTokSubscribeEvent(WebcastMemberMessage msg) {
+    super(msg.getHeader());
+
+    if(msg.hasUser())
+    {
+      newSubscriber = new User(msg.getUser());
+    }
+  }
+
+}

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

@@ -0,0 +1,33 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastUnauthorizedMemberMessage;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+public class TikTokUnauthorizedMemberEvent extends TikTokEvent {
+    private final String data;
+
+    private final UnauthorizedMemberData event;
+
+    private final UnauthorizedMemberData underlying;
+
+    public TikTokUnauthorizedMemberEvent(WebcastUnauthorizedMemberMessage msg) {
+        super(msg.getHeader());
+
+        data = msg.getData2();
+        event = new UnauthorizedMemberData(msg.getDetails1().getType(), msg.getDetails1().getLabel());
+        underlying = new UnauthorizedMemberData(msg.getDetails2().getType(), msg.getDetails2().getLabel());
+    }
+
+
+    @Getter
+    @AllArgsConstructor
+    public class UnauthorizedMemberData {
+        private final String data1;
+
+        private final String data2;
+    }
+
+}

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

@@ -0,0 +1,13 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastControlMessage;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TikTokUnhandledControlEvent extends TikTokEvent {
+
+    private final WebcastControlMessage message;
+}

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

@@ -0,0 +1,14 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+
+@Getter
+@AllArgsConstructor
+public class TikTokUnhandledEvent extends TikTokEvent
+{
+    private final WebcastResponse.Message message;
+}

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

@@ -0,0 +1,13 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastMemberMessage;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TikTokUnhandledMemberEvent extends TikTokEvent
+{
+    private final WebcastMemberMessage message;
+}

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

@@ -0,0 +1,13 @@
+package io.github.jwdeveloper.tiktok.events.messages;
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastSocialMessage;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TikTokUnhandledSocialEvent extends TikTokEvent
+{
+    private final WebcastSocialMessage message;
+}

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

@@ -0,0 +1,41 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class Badge {
+    private final 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());
+    }
+
+
+    @AllArgsConstructor
+    @Getter
+    public class TextBadge {
+        private final String type;
+        private final String name;
+    }
+
+    @AllArgsConstructor
+    @Getter
+    public class ImageBadge {
+        private final Integer displayType;
+        private final Picture image;
+    }
+
+    @AllArgsConstructor
+    @Getter
+    public class ComboBadge {
+        private final Picture image;
+        private final String data;
+    }
+}

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

@@ -0,0 +1,29 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class BarrageData {
+  private final String eventType;
+  private final String label;
+  private final List<BarrageUser> users;
+
+  public BarrageData(String eventType, String label, List<BarrageUser> users)
+  {
+    this.eventType = eventType;
+    this.label = label;
+    this.users = users;
+  }
+
+  @Getter
+  @AllArgsConstructor
+  public static final class BarrageUser
+  {
+      private final User user;
+
+      private final String data;
+  }
+}

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

@@ -0,0 +1,27 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.Getter;
+
+@Getter
+public class Gift {
+    private final Long id;
+
+    private final String name;
+
+    private final String description;
+
+    private final Integer diamondCost;
+
+    private final Integer type;
+
+    private final Picture picture;
+
+    public Gift(io.github.jwdeveloper.tiktok.messages.Gift gift) {
+        id = gift.getId();
+        name = gift.getName();
+        description = gift.getDescription();
+        diamondCost = gift.getCoinCount();
+        type = gift.getGiftType();
+        picture = new Picture(gift.getImage());
+    }
+}

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

@@ -0,0 +1,31 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import io.github.jwdeveloper.tiktok.messages.LinkMicArmiesItems;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class LinkMicArmy {
+    private final Long armyId;
+    private final List<Army> armies;
+
+    public LinkMicArmy(LinkMicArmiesItems army) {
+        armyId = army.getHostUserId();
+        armies = army.getBattleGroupsList()
+                .stream()
+                .map(x -> new Army(x.getUsersList()
+                        .stream()
+                        .map(User::new).toList(), x.getPoints()))
+                .toList();
+    }
+
+
+    @Getter
+    @AllArgsConstructor
+    public final class Army {
+        private final List<User> Users;
+        private final Integer Points;
+    }
+}

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

@@ -0,0 +1,18 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+
+import io.github.jwdeveloper.tiktok.messages.WebcastLinkMicBattle;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+public class LinkMicBattleTeam {
+    private final Long teamId;
+    private final List<User> users;
+
+    public LinkMicBattleTeam(WebcastLinkMicBattle.LinkMicBattleTeam team) {
+        this.teamId = team.getId();
+        this.users = team.getUsersList().stream().map(User::new).toList();
+    }
+}

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

@@ -0,0 +1,25 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.Getter;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Getter
+public class Picture {
+
+  public final List<String> urls;
+
+  public Picture(io.github.jwdeveloper.tiktok.messages.Picture profilePicture) {
+    this.urls = profilePicture.getUrlsList();
+  }
+
+  public Picture(List<String> urls) {
+    this.urls = urls;
+  }
+
+  public Picture(String ... urls)
+  {
+    this.urls = Arrays.stream(urls).toList();
+  }
+}

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

@@ -0,0 +1,22 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+@AllArgsConstructor
+public class PollOption {
+
+    private final User user;
+    private final List<Option> options;
+
+    @Getter
+    @AllArgsConstructor
+    public static final class Option {
+        private final String label;
+
+        private final Integer total;
+    }
+}

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

@@ -0,0 +1,25 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import io.github.jwdeveloper.tiktok.messages.WebcastGiftMessage;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class TikTokGift {
+    private final Gift gift;
+    private User sender;
+    @Setter
+    private int amount;
+
+    @Setter
+    private  boolean streakFinished;
+
+    public TikTokGift(WebcastGiftMessage message) {
+        gift = new Gift(message.getGiftDetails());
+        if (message.hasSender()) {
+            sender = new User(message.getSender());
+        }
+        amount = message.getAmount();
+        streakFinished = message.getRepeatEnd();
+    }
+}

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

@@ -0,0 +1,22 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.Getter;
+
+@Getter
+public class TopViewer {
+  private Integer rank;
+
+  private User user;
+
+  private Integer coinsGiven;
+
+  public TopViewer(io.github.jwdeveloper.tiktok.messages.TopViewer viewer)
+  {
+    rank = viewer.getRank();
+    if(viewer.hasUser())
+    {
+      user = new User(viewer.getUser());
+    }
+    coinsGiven = viewer.getCoinsGiven();
+  }
+}

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

@@ -0,0 +1,87 @@
+package io.github.jwdeveloper.tiktok.events.objects;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+public class User {
+    private Long userId;
+    private String uniqueId;
+
+    private final String nickName;
+
+    private String description;
+
+    private Picture profilePicture;
+
+    private Picture picture720;
+
+    private Picture picture1080;
+
+    private Integer following;
+
+    private Integer followers;
+
+    private Integer followsHost;
+    public List<Picture> additionalPictures;
+
+    public List<Badge> badges;
+
+    public User(Long userId,
+                String uniqueId,
+                String nickName,
+                String description,
+                Picture profilePicture,
+                Picture picture720,
+                Picture picture1080,
+                List<Picture> additionalPictures,
+                Integer following,
+                Integer followers,
+                Integer followsHost,
+                List<Badge> badges) {
+        this.userId = userId;
+        this.uniqueId = uniqueId;
+        this.nickName = nickName;
+        this.description = description;
+        this.profilePicture = profilePicture;
+        this.picture720 = picture720;
+        this.picture1080 = picture1080;
+        this.additionalPictures = additionalPictures;
+        this.following = following;
+        this.followers = followers;
+        this.followsHost = followsHost;
+        this.badges = badges;
+    }
+
+    public User(String uniqueId,
+                String nickName) {
+        this.uniqueId = uniqueId;
+        this.nickName = nickName;
+    }
+
+    public User(Long userId,
+                String nickName,
+                Picture picture) {
+        this.userId = userId;
+        this.nickName = nickName;
+        this.profilePicture = picture;
+    }
+
+    public User(io.github.jwdeveloper.tiktok.messages.User user) {
+        assert user != null;
+        userId = user.getUserId();
+        uniqueId = user.getUniqueId();
+        nickName = user.getNickname();
+        description = user.getDescription();
+        profilePicture = new Picture(user.getProfilePicture());
+        picture720 = new Picture(user.getPicture720());
+        picture1080 = new Picture(user.getPicture1080());
+        following = user.getFollowerData().getFollowing();
+        followers = user.getFollowerData().getFollowers();
+        followsHost = user.getFollowerData().getFollowsHost();
+        badges = user.getBadgesList().stream().map(Badge::new).toList();
+        additionalPictures = new ArrayList<>();
+    }
+}

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok;
+package io.github.jwdeveloper.tiktok.exceptions;
 
 public class TikTokLiveException extends RuntimeException
 {

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

@@ -1,6 +1,7 @@
 package io.github.jwdeveloper.tiktok.live;
 
 public interface LiveClient {
+
     void run();
 
     void stop();

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

@@ -1,6 +0,0 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
-
-public class LockInfo
-{
-    public int lock_type;
-}

API/src/main/java/io/github/jwdeveloper/tiktok/live/models/gift/SpecialEffects.java

@@ -1,4 +0,0 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
-
-public class SpecialEffects {
-}

API/src/main/java/io/github/jwdeveloper/tiktok/live/models/gift/TrackerParams.java

@@ -1,4 +0,0 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
-
-public class TrackerParams {
-}

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

@@ -0,0 +1,13 @@
+package io.github.jwdeveloper.tiktok.models;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class GiftId
+{
+    public long Gift;
+
+    public String UserName;
+}

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

@@ -0,0 +1,9 @@
+package io.github.jwdeveloper.tiktok.models;
+
+public class SocialTypes
+{
+    public static final String LikeType = "pm_mt_msg_viewer";
+    public static final String FollowType = "pm_main_follow_message_viewer_2";
+    public static final String ShareType = "pm_mt_guidance_share";
+    public static final String JoinType = "pm_mt_join_message_other_viewer";
+}

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -0,0 +1,6 @@
+package io.github.jwdeveloper.tiktok.models.gifts;
+
+public class LockInfo
+{
+    public int lock_type;
+}

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

@@ -0,0 +1,4 @@
+package io.github.jwdeveloper.tiktok.models.gifts;
+
+public class SpecialEffects {
+}

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

@@ -1,4 +1,4 @@
-package io.github.jwdeveloper.tiktok.live.models.gift;
+package io.github.jwdeveloper.tiktok.models.gifts;
 
 import lombok.Data;
 

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

@@ -0,0 +1,4 @@
+package io.github.jwdeveloper.tiktok.models.gifts;
+
+public class TrackerParams {
+}

Client/pom.xml

@@ -4,7 +4,7 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
-        <groupId>org.example</groupId>
+        <groupId>io.github.jwdeveloper.tiktok</groupId>
         <version>1.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
@@ -17,43 +17,6 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
-    <build>
-        <sourceDirectory>target/generated-sources/protobuf/java</sourceDirectory>
-        <plugins>
-            <plugin>
-                <groupId>kr.motd.maven</groupId>
-                <artifactId>os-maven-plugin</artifactId>
-                <version>1.7.0</version>
-                <executions>
-                    <execution>
-                        <phase>initialize</phase>
-                        <goals>
-                            <goal>detect</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>org.xolstice.maven.plugins</groupId>
-                <artifactId>protobuf-maven-plugin</artifactId>
-                <version>0.6.1</version>
-                <configuration>
-                    <protocArtifact>com.google.protobuf:protoc:3.17.3:exe:${os.detected.classifier}</protocArtifact>
-                </configuration>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>compile</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <!-- Add other plugins as needed -->
-        </plugins>
-    </build>
-
 
     <dependencies>
         <dependency>
@@ -61,11 +24,13 @@
             <artifactId>Java-WebSocket</artifactId>
             <version>1.5.4</version>
         </dependency>
+
         <dependency>
-            <groupId>com.google.protobuf</groupId>
+            <groupId>org.slf4j</groupId>
-            <artifactId>protobuf-java</artifactId>
+            <artifactId>slf4j-api</artifactId>
-            <version>3.23.0</version>
+            <version>1.7.0</version>
         </dependency>
+
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
@@ -73,7 +38,6 @@
             <scope>compile</scope>
         </dependency>
 
-        <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
@@ -87,9 +51,6 @@
             <scope>test</scope>
         </dependency>
 
-
-
-
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
@@ -103,7 +64,7 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.example</groupId>
+            <groupId>io.github.jwdeveloper.tiktok</groupId>
             <artifactId>API</artifactId>
             <version>1.0-SNAPSHOT</version>
             <scope>compile</scope>

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

@@ -1,97 +0,0 @@
-package io.github.jwdeveloper.tiktok;
-
-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.TikTokLiveMeta;
-import io.github.jwdeveloper.tiktok.websocket.TikTokWebsocketClient;
-
-import java.time.Duration;
-import java.util.Map;
-import java.util.function.Consumer;
-import java.util.logging.Logger;
-
-public class TikTokClientBuilder {
-    private String userName;
-    private final ClientSettings clientSettings;
-    private Map<String, Object> clientParameters;
-    private Logger logger;
-
-    public TikTokClientBuilder(String userName) {
-        this.userName = userName;
-        this.clientSettings = Constants.DefaultClientSettings();
-        this.clientParameters = Constants.DefaultClientParams();
-        this.logger = Logger.getLogger(TikTokLive.class.getName());
-    }
-
-    public TikTokClientBuilder clientSettings(Consumer<ClientSettings> consumer) {
-        consumer.accept(clientSettings);
-        return this;
-    }
-
-    public TikTokClientBuilder hostUserName(String userName) {
-        this.userName = userName;
-        return this;
-    }
-
-    public TikTokClientBuilder clientParameters(Map<String, Object> clientParameters) {
-        this.clientParameters = clientParameters;
-        return this;
-    }
-
-    public TikTokClientBuilder 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 (userName == null || userName.equals("")) {
-            throw new RuntimeException("UserName can not be null");
-        }
-
-        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 TikTokLiveMeta();
-        meta.setUserName(userName);
-
-
-        var cookieJar = new TikTokCookieJar();
-        var requestFactory = new TikTokHttpRequestFactory(cookieJar);
-        var apiClient = new TikTokHttpApiClient(cookieJar,clientSettings, requestFactory);
-        var apiService = new TikTokApiService(apiClient, logger,clientParameters);
-        var webSocketClient = new TikTokWebsocketClient(logger, cookieJar,clientParameters, requestFactory,clientSettings);
-        var giftManager =new TikTokGiftManager(logger, apiService, clientSettings);
-        return new TikTokLiveClient(meta,apiService, webSocketClient, giftManager, logger);
-    }
-}

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

@@ -1,7 +1,10 @@
 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.models.gift.TikTokGift;
+import io.github.jwdeveloper.tiktok.models.GiftId;
+
+import lombok.Getter;
 
 import java.util.HashMap;
 import java.util.List;
@@ -14,11 +17,15 @@ public class TikTokGiftManager {
     private TikTokApiService apiService;
     private Map<Integer, TikTokGift> gifts;
 
+    @Getter
+    private 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<>();
+        activeGifts = new HashMap<>();
     }
 
     public void loadGifts() {
@@ -26,11 +33,13 @@ public class TikTokGiftManager {
             return;
         }
         logger.info("Fetching gifts");
-        gifts =apiService.fetchAvailableGifts();
+        //TODO gifts =apiService.fetchAvailableGifts();
     }
 
     public List<TikTokGift> getGifts()
     {
         return gifts.values().stream().toList();
     }
+
+
 }

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

@@ -4,8 +4,10 @@ package io.github.jwdeveloper.tiktok;
 
 public class TikTokLive
 {
-    public static TikTokClientBuilder newClient(String userName)
+    public static TikTokLiveClientBuilder newClient(String userName)
     {
-        return new TikTokClientBuilder(userName);
+        return new TikTokLiveClientBuilder(userName);
     }
+
+
 }

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

@@ -1,5 +1,7 @@
 package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+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.LiveClient;
@@ -14,6 +16,8 @@ public class TikTokLiveClient implements LiveClient {
     private final TikTokGiftManager giftManager;
     private final TikTokApiService apiClient;
     private final TikTokWebsocketClient webSocketClient;
+
+    private final TikTokEventHandler tikTokEventHandler;
     private final Logger logger;
 
 
@@ -21,15 +25,19 @@ public class TikTokLiveClient implements LiveClient {
                             TikTokApiService tikTokApiService,
                             TikTokWebsocketClient webSocketClient,
                             TikTokGiftManager tikTokGiftManager,
+                            TikTokEventHandler tikTokEventHandler,
                             Logger logger) {
         this.meta = tikTokLiveMeta;
         this.giftManager = tikTokGiftManager;
         this.apiClient = tikTokApiService;
         this.webSocketClient = webSocketClient;
         this.logger = logger;
+        this.tikTokEventHandler = tikTokEventHandler;
     }
 
 
+
+
     public void run() {
         tryConnect();
     }

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

@@ -0,0 +1,295 @@
+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.messages.*;
+import io.github.jwdeveloper.tiktok.handlers.WebResponseHandler;
+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.TikTokLiveMeta;
+import io.github.jwdeveloper.tiktok.websocket.TikTokWebsocketClient;
+import io.github.jwdeveloper.tiktok.handlers.WebResponseHandlerBase;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
+
+public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveClientBuilder> {
+    private String userName;
+    private final ClientSettings clientSettings;
+    private Map<String, Object> clientParameters;
+    private Logger logger;
+    private TikTokEventHandler tikTokEventHandler;
+
+    public TikTokLiveClientBuilder(String userName) {
+        this.tikTokEventHandler = new TikTokEventHandler();
+        this.userName = userName;
+        this.clientSettings = Constants.DefaultClientSettings();
+        this.clientParameters = Constants.DefaultClientParams();
+        this.logger = Logger.getLogger(TikTokLive.class.getName());
+    }
+
+
+
+
+    public TikTokLiveClientBuilder clientSettings(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 (userName == null || userName.equals("")) {
+            throw new RuntimeException("UserName can not be null");
+        }
+
+        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 TikTokLiveMeta();
+        meta.setUserName(userName);
+
+
+        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, cookieJar, clientParameters, requestFactory, clientSettings, webResponseHandler);
+
+        return new TikTokLiveClient(meta, apiService, webSocketClient, giftManager, tikTokEventHandler, logger);
+    }
+
+    public LiveClient buildAndRun() {
+        var client = build();
+        client.run();
+        return client;
+    }
+
+    public TikTokLiveClientBuilder onLinkMicFanTicket(Consumer<TikTokLinkMicFanTicketEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onEnvelope(Consumer<TikTokEnvelopeEvent> event) {
+        tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onShopMessage(Consumer<TikTokShopMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokShopMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onDetectMessage(Consumer<TikTokDetectMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokDetectMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkLayerMessage(Consumer<TikTokLinkLayerMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkLayerMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onDisconnected(Consumer<TikTokDisconnectedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onConnected(Consumer<TikTokConnectedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokConnectedEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onCaption(Consumer<TikTokCaptionEvent> event) {
+        tikTokEventHandler.subscribe(TikTokCaptionEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onQuestion(Consumer<TikTokQuestionEvent> event) {
+        tikTokEventHandler.subscribe(TikTokQuestionEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onRoomPinMessage(Consumer<TikTokRoomPinMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomPinMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onRoomMessage(Consumer<TikTokRoomMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLike(Consumer<TikTokLikeEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMessage(Consumer<TikTokLinkMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onBarrageMessage(Consumer<TikTokBarrageMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokBarrageMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onGiftMessage(Consumer<TikTokGiftMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokGiftMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMicArmies(Consumer<TikTokLinkMicArmiesEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onEmote(Consumer<TikTokEmoteEvent> event) {
+        tikTokEventHandler.subscribe(TikTokEmoteEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onUnauthorizedMember(Consumer<TikTokUnauthorizedMemberEvent> event) {
+        tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onInRoomBanner(Consumer<TikTokInRoomBannerEvent> event) {
+        tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMicMethod(Consumer<TikTokLinkMicMethodEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onSubscribe(Consumer<TikTokSubscribeEvent> event) {
+        tikTokEventHandler.subscribe(TikTokSubscribeEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onPollMessage(Consumer<TikTokPollMessageEvent> event) {
+        tikTokEventHandler.subscribe(TikTokPollMessageEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onFollow(Consumer<TikTokFollowEvent> event) {
+        tikTokEventHandler.subscribe(TikTokFollowEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onRoomViewerData(Consumer<TikTokRoomViewerDataEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomViewerDataEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onGoalUpdate(Consumer<TikTokGoalUpdateEvent> event) {
+        tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onComment(Consumer<TikTokCommentEvent> event) {
+        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onRankUpdate(Consumer<TikTokRankUpdateEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onIMDelete(Consumer<TikTokIMDeleteEvent> event) {
+        tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onJoin(Consumer<TikTokJoinEvent> event) {
+        tikTokEventHandler.subscribe(TikTokJoinEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onRankText(Consumer<TikTokRankTextEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRankTextEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onShare(Consumer<TikTokShareEvent> event) {
+        tikTokEventHandler.subscribe(TikTokShareEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onSubNotify(Consumer<TikTokSubNotifyEvent> event) {
+        tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onLinkMicBattle(Consumer<TikTokLinkMicBattleEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onGiftBroadcast(Consumer<TikTokGiftBroadcastEvent> event) {
+        tikTokEventHandler.subscribe(TikTokGiftBroadcastEvent.class, event);
+        return this;
+    }
+
+    public TikTokLiveClientBuilder onEvent(Consumer<TikTokEvent> event)
+    {
+        tikTokEventHandler.subscribe(TikTokEvent.class,event);
+        return this;
+    }
+}
+
+
+
+

Client/src/main/java/io/github/jwdeveloper/tiktok/events/TikTokChatEvent.java

@@ -1,4 +0,0 @@
-package io.github.jwdeveloper.tiktok.events;
-
-public class TikTokChatEvent {
-}

Client/src/main/java/io/github/jwdeveloper/tiktok/events/TikTokEvent.java

@@ -1,6 +0,0 @@
-package io.github.jwdeveloper.tiktok.events;
-
-public class TikTokEvent
-{
-
-}

Client/src/main/java/io/github/jwdeveloper/tiktok/events/TikTokGiftEvent.java

@@ -1,4 +0,0 @@
-package io.github.jwdeveloper.tiktok.events;
-
-public class TikTokGiftEvent {
-}

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

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

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

@@ -0,0 +1,12 @@
+package io.github.jwdeveloper.tiktok.handlers;
+
+
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+
+public interface TikTokMessageHandler<T>
+{
+     Class<T> getHandleClazz();
+
+    TikTokEvent handle(WebcastResponse.Message message) throws Exception;
+}

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

@@ -0,0 +1,149 @@
+package io.github.jwdeveloper.tiktok.handlers;
+
+import io.github.jwdeveloper.tiktok.TikTokGiftManager;
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.events.messages.*;
+import io.github.jwdeveloper.tiktok.events.objects.TikTokGift;
+import io.github.jwdeveloper.tiktok.messages.*;
+import io.github.jwdeveloper.tiktok.models.GiftId;
+import io.github.jwdeveloper.tiktok.models.SocialTypes;
+import lombok.SneakyThrows;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class WebResponseHandler extends WebResponseHandlerBase {
+    private final TikTokGiftManager giftManager;
+
+    public WebResponseHandler(TikTokEventHandler tikTokEventHandler, TikTokGiftManager giftManager) {
+        super(tikTokEventHandler);
+        this.giftManager = giftManager;
+    }
+
+    @Override
+    public void init() {
+
+        //ConnectionEvents events
+        register(WebcastControlMessage.class, TikTokRoomMessageEvent.class);
+        register(SystemMessage.class, this::handleWebcastControlMessage);
+
+
+        //Room status events
+        register(WebcastLiveIntroMessage.class, TikTokRoomMessageEvent.class);
+        register(WebcastRoomUserSeqMessage.class, TikTokRoomViewerDataEvent.class); //TODO update viewer count    ViewerCount = userSeqMessage.ViewerCount;
+        register(RoomMessage.class, TikTokRoomMessageEvent.class);
+        register(WebcastRoomMessage.class, TikTokRoomMessageEvent.class);
+        register(WebcastCaptionMessage.class, TikTokCaptionEvent.class);
+
+        //User Interactions events
+        register(WebcastChatMessage.class, TikTokCommentEvent.class);
+        register(WebcastLikeMessage.class, TikTokLikeEvent.class);
+        register(WebcastGiftMessage.class, this::handleGift);
+        register(WebcastSocialMessage.class, this::handleSocialMedia);
+        register(WebcastMemberMessage.class, this::handleMemberMessage);
+
+        //Host Interaction events
+        register(WebcastPollMessage.class, TikTokPollMessageEvent.class);
+        register(WebcastRoomPinMessage.class, TikTokRoomPinMessageEvent.class);
+        register(WebcastGoalUpdateMessage.class, TikTokGoalUpdateEvent.class);
+
+        //LinkMic events
+        register(WebcastLinkMicBattle.class, TikTokLinkMicBattleEvent.class);
+        register(WebcastLinkMicArmies.class, TikTokLinkMicArmiesEvent.class);
+        register(LinkMicMethod.class, TikTokLinkMicMethodEvent.class);
+        register(WebcastLinkMicMethod.class, TikTokLinkMicMethodEvent.class);
+        register(WebcastLinkMicFanTicketMethod.class, TikTokLinkMicFanTicketEvent.class);
+
+        //Rank events
+        register(WebcastRankTextMessage.class, TikTokRankTextEvent.class);
+        register(WebcastRankUpdateMessage.class, TikTokRankUpdateEvent.class);
+        register(WebcastHourlyRankMessage.class, TikTokRankUpdateEvent.class);
+
+        //Others events
+        register(WebcastInRoomBannerMessage.class, TikTokInRoomBannerEvent.class);
+        register(WebcastMsgDetectMessage.class, TikTokDetectMessageEvent.class);
+        register(WebcastBarrageMessage.class, TikTokBarrageMessageEvent.class);
+        register(WebcastUnauthorizedMemberMessage.class, TikTokUnauthorizedMemberEvent.class);
+        register(WebcastGiftBroadcastMessage.class, TikTokGiftBroadcastEvent.class);
+        register(WebcastOecLiveShoppingMessage.class, TikTokShopMessageEvent.class);
+        register(WebcastImDeleteMessage.class, TikTokIMDeleteEvent.class);
+        register(WebcastQuestionNewMessage.class, TikTokQuestionEvent.class);
+        register(WebcastEnvelopeMessage.class, TikTokEnvelopeEvent.class);
+        register(WebcastSubNotifyMessage.class, TikTokSubNotifyEvent.class);
+        register(WebcastEmoteChatMessage.class, TikTokEmoteEvent.class);
+    }
+
+
+    @SneakyThrows
+    private TikTokEvent handleWebcastControlMessage(WebcastResponse.Message msg)
+    {
+        var message = WebcastControlMessage.parseFrom(msg.getBinary());
+        return switch (message.getAction()) {
+            case STREAM_PAUSED -> new TikTokLivePausedEvent();
+            case STREAM_ENDED -> new TikTokLiveEndedEvent();
+            default -> new TikTokUnhandledControlEvent(message);
+        };
+    }
+
+    @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");
+
+        return new TikTokGiftMessageEvent(giftMessage);
+    }
+
+    @SneakyThrows
+    private TikTokEvent handleSocialMedia(WebcastResponse.Message msg) {
+        var message = WebcastSocialMessage.parseFrom(msg.getBinary());
+
+        String type = message.getHeader().getSocialData().getType();
+        Pattern pattern = Pattern.compile("pm_mt_guidance_viewer_([0-9]+)_share");
+        Matcher matcher = pattern.matcher(type);
+        if (matcher.find()) {
+            var value = matcher.group(0);
+            var number = Integer.parseInt(value);
+            return new TikTokShareEvent(message, number);
+        }
+
+        var socialType = message.getHeader().getSocialData().getType();
+        return switch (socialType) {
+            case SocialTypes.LikeType -> new TikTokLikeEvent(message);
+            case SocialTypes.FollowType -> new TikTokFollowEvent(message);
+            case SocialTypes.ShareType -> new TikTokShareEvent(message);
+            case SocialTypes.JoinType -> new TikTokJoinEvent(message);
+            default -> new TikTokUnhandledSocialEvent(message);
+        };
+    }
+
+    @SneakyThrows
+    private TikTokEvent handleMemberMessage(WebcastResponse.Message msg) {
+        var message = WebcastMemberMessage.parseFrom(msg.getBinary());
+        return switch (message.getAction()) {
+            case JOINED -> new TikTokJoinEvent(message);
+            case SUBSCRIBED -> new TikTokSubscribeEvent(message);
+            default -> new TikTokUnhandledMemberEvent(message);
+        };
+    }
+}

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

@@ -0,0 +1,89 @@
+package io.github.jwdeveloper.tiktok.handlers;
+
+
+import com.google.protobuf.ByteString;
+import io.github.jwdeveloper.tiktok.events.messages.*;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.events.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.*;
+
+import java.util.Arrays;
+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;
+    }
+
+    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 TikTokLiveException("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) {
+       // System.out.println("==============================================================");
+     //   System.out.println("Getting messages: " + webcastResponse.getMessagesList().size());
+        for (var message : webcastResponse.getMessagesList()) {
+            try {
+                handleSingleMessage(message);
+            } catch (Exception e) {
+                throw new TikTokLiveException("Error whilst Handling Message. Stopping Client.{Environment.NewLine}Final Message: {Convert.ToBase64String(message.Binary)}", e);
+            }
+        }
+      //  System.out.println("==============================================================");
+    }
+
+    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/TikTokApiService.java

@@ -1,11 +1,10 @@
 package io.github.jwdeveloper.tiktok.http;
 
 import com.google.gson.Gson;
-import com.google.gson.JsonParser;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
-import io.github.jwdeveloper.generated.WebcastResponse;
-import io.github.jwdeveloper.tiktok.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
-import io.github.jwdeveloper.tiktok.live.models.gift.TikTokGift;
+import io.github.jwdeveloper.tiktok.models.gifts.TikTokGift;
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -89,7 +88,7 @@ public class TikTokApiService {
         try {
             var response = apiClient.GetDeserializedMessage("im/fetch/", clientParams);
             clientParams.put("cursor",response.getCursor());
-            clientParams.put("internal_ext", response.getInternalExt());
+            clientParams.put("internal_ext", response.getAckIds());
             return response;
         }
         catch (Exception e)

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

@@ -18,10 +18,6 @@ public class TikTokCookieJar {
         cookies.put(key, value);
     }
 
-    public Set<Map.Entry<String, String>> GetEnumerator() {
-        return cookies.entrySet();
-    }
-
     public String parseCookies()
     {
         var sb = new StringBuilder();

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

@@ -2,17 +2,16 @@ package io.github.jwdeveloper.tiktok.http;
 
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
-import io.github.jwdeveloper.generated.WebcastResponse;
 import io.github.jwdeveloper.tiktok.ClientSettings;
 import io.github.jwdeveloper.tiktok.Constants;
-import io.github.jwdeveloper.tiktok.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
 
 import java.net.URI;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -81,7 +80,6 @@ public class TikTokHttpApiClient {
                 var key = split[0];
                 var value = split[1];
                 tikTokCookieJar.set(key, value);
-                var i =0;
             }
 
             return response.body();

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

@@ -1,101 +1,77 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
-import com.google.protobuf.ByteString;
-import io.github.jwdeveloper.generated.WebcastMessageEvent;
-import io.github.jwdeveloper.generated.WebcastResponse;
-import io.github.jwdeveloper.generated.WebcastWebsocketAck;
-import io.github.jwdeveloper.generated.WebcastWebsocketMessage;
-import io.github.jwdeveloper.tiktok.TikTokLiveException;
 
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.messages.WebcastResponse;
+import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketAck;
+import io.github.jwdeveloper.tiktok.messages.WebcastWebsocketMessage;
+
+import java.io.ByteArrayOutputStream;
 import java.net.http.WebSocket;
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
 import java.util.Base64;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 
 
 public class TikTokWebSocketListener implements java.net.http.WebSocket.Listener {
 
-    List<ByteBuffer> parts = new ArrayList<>();
+    private ByteArrayOutputStream accumulatedData = new ByteArrayOutputStream();
-    CompletableFuture<?> accumulatedMessage = new CompletableFuture<>();
 
     @Override
     public CompletionStage<?> onBinary(WebSocket webSocket, ByteBuffer data, boolean last) {
-        System.out.println("Received onBinary: " + data + " " + last);
-        parts.add(data);
-        webSocket.request(1);
-        if (last) {
-            var buffer = combineBuffer(parts);
-            accumulatedMessage.complete(null);
-            CompletionStage<?> cf = accumulatedMessage;
-            accumulatedMessage = new CompletableFuture<>();
-            handleBinary(webSocket, buffer);
-            parts = new ArrayList<>();
-            return cf;
-        }
-        return accumulatedMessage;
-    }
-
-
-    public ByteBuffer combineBuffer(List<ByteBuffer> buffers) {
-        int totalCapacity = buffers.stream().mapToInt(ByteBuffer::remaining).sum();
-        ByteBuffer combined = ByteBuffer.allocate(totalCapacity);
-        for (ByteBuffer buffer : buffers) {
-            combined.put(buffer);
-        }
-        combined.flip();
-        return combined;
-    }
-
-
-    private void handleBinary(WebSocket webSocket, ByteBuffer buffer) {
         try {
-         //   buffer= Base64.getEncoder().encode(buffer);
+            var decoded = Base64.getEncoder().encodeToString(data.array());
-            ByteString byteString = ByteString.copyFrom(buffer);
+            System.out.println(decoded);
-            WebcastWebsocketMessage websocketMessage = WebcastWebsocketMessage.parseFrom(byteString);
+            var bytes = new byte[data.remaining()];
+            data.get(bytes);
+            accumulatedData.write(bytes);
+            if (last) {
 
-            if(websocketMessage.getBinary().isEmpty())
+                //handleBinary(webSocket, accumulatedData.toByteArray());
-            {
+                accumulatedData.reset();
-                return;
+                accumulatedData = new ByteArrayOutputStream();
-            }
-            try {
-                var response = WebcastResponse.parseFrom(websocketMessage.getBinary());
-
-                var serverInfo = WebcastWebsocketAck
-                        .newBuilder()
-                        .setType("ack")
-                        .setId(websocketMessage.getId())
-                        .build();
-                webSocket.sendBinary(serverInfo.toByteString().asReadOnlyByteBuffer(), true);
-
-                System.out.println("Works");
-              //  handleResponse(response);
-            } catch (Exception e) {
-               throw new TikTokLiveException("Unabel to read WebcastResponse",e);
-        //     System.out.println("Unable to read WebcastResponse");
             }
         } catch (Exception e) {
-
-          //  System.out.println("Unable to read WebcastWebsocketMessage");
             e.printStackTrace();
-            throw new TikTokLiveException("Unabel to read WebcastWebsocketMessage",e);
+        }
+        webSocket.request(1);
+        return null;
+    }
+
+    private void handleBinary(WebSocket webSocket, byte[] buffer) {
+        try {
+
+            var websocketMessage = WebcastWebsocketMessage.parseFrom(buffer);
+            if (websocketMessage.getBinary().isEmpty()) {
+                return;
+            }
+            sendAckId(webSocket, websocketMessage.getId());
+
+
+            try {
+
+                //error here
+                var response = WebcastResponse.parseFrom(websocketMessage.getBinary());
+                System.out.println("Works");
+                //  handleResponse(response);
+            } catch (Exception e) {
+                throw new TikTokLiveException("Unabel to read WebcastResponse", e);
+            }
+        } catch (Exception e) {
+            throw new TikTokLiveException("Unabel to read WebcastWebsocketMessage", e);
         }
     }
 
 
-    public void handleResponse(WebcastResponse webcastResponse) {
+    private void sendAckId(WebSocket webSocket, long id) {
-        System.out.println("Handling response: Messages"+webcastResponse.getMessagesList().size());
+        var serverInfo = WebcastWebsocketAck
-
+                .newBuilder()
-        for(var message  : webcastResponse.getMessagesList())
+                .setType("ack")
-        {
+                .setId(id)
-
+                .build();
-
+        webSocket.sendBinary(serverInfo.toByteString().asReadOnlyByteBuffer(), true);
-        }
     }
 
-
     @Override
     public void onOpen(java.net.http.WebSocket webSocket) {
         System.out.println("WebSocket opened");

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

@@ -1,15 +1,17 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
-import io.github.jwdeveloper.generated.WebcastResponse;
+
 import io.github.jwdeveloper.tiktok.ClientSettings;
 import io.github.jwdeveloper.tiktok.Constants;
-import io.github.jwdeveloper.tiktok.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.handlers.WebResponseHandlerBase;
 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.drafts.Draft_6455;
 
 import java.net.URI;
-import java.net.http.HttpClient;
 import java.nio.ByteBuffer;
 import java.time.Duration;
 import java.util.HashMap;
@@ -23,47 +25,47 @@ public class TikTokWebsocketClient {
     private final ClientSettings clientSettings;
     private final TikTokCookieJar tikTokCookieJar;
     private final TikTokHttpRequestFactory factory;
+    private final WebResponseHandlerBase webResponseHandler;
 
     public TikTokWebsocketClient(Logger logger,
                                  TikTokCookieJar tikTokCookieJar,
                                  Map<String, Object> clientParams,
                                  TikTokHttpRequestFactory factory,
-                                 ClientSettings clientSettings) {
+                                 ClientSettings clientSettings,
+                                 WebResponseHandlerBase webResponseHandler) {
         this.logger = logger;
         this.clientParams = clientParams;
         this.tikTokCookieJar = tikTokCookieJar;
         this.clientSettings = clientSettings;
         this.factory = factory;
+        this.webResponseHandler = webResponseHandler;
     }
 
     public void start(WebcastResponse webcastResponse) {
-        if (webcastResponse.getWsUrl().isEmpty() || webcastResponse.getWsParam().getAllFields().isEmpty()) {
+        if (webcastResponse.getSocketUrl().isEmpty() || webcastResponse.getSocketParamsList().isEmpty()) {
             throw new TikTokLiveException("Could not find Room");
         }
-
-
         try {
 
-            var params = webcastResponse.getWsParam();
+            var params = webcastResponse.getSocketParamsList().get(0);
             var name = params.getName();
             var value = params.getValue();
-            System.out.println("KEY: " + name + " value: " + value);
+           // System.out.println("KEY: " + name + " value: " + value);
 
 
             var headers = Constants.DefaultRequestHeaders();
 
 
             var clone = new TreeMap<>(clientParams);
-            //  clone.putAll(headers);
+            clone.putAll(headers);
             clone.put(name, value);
-            clone.put("compress", "gzip");
+            //clone.put("compress", "gzip");
-
+            var url = webcastResponse.getSocketUrl();
-            var url = webcastResponse.getWsUrl();
             var wsUrl = HttpUtils.parseParametersEncode(url, clone);
             logger.info("Starting Socket-Threads");
             //runningTask = Task.Run(WebSocketLoop, token);
             //pollingTask = Task.Run(PingLoop, token);
-            startWS(wsUrl);
+            startWS2(wsUrl);
         } catch (Exception e) {
             throw new TikTokLiveException("Failed to connect to the websocket", e);
         }
@@ -85,14 +87,13 @@ public class TikTokWebsocketClient {
             var map = new HashMap<String, String>();
             map.put("Cookie", cookie);
 
-            var ws =  factory.openSocket()
+            var ws = factory.openSocket()
                     .subprotocols("echo-protocol")
                     .connectTimeout(Duration.ofSeconds(15))
                     .header("Cookie", cookie)
                     .buildAsync(URI.create(url), new TikTokWebSocketListener()).get();
 
 
-
             while (true) {
                 byte[] message = new byte[]{58, 2, 104, 98};
                 ByteBuffer buffer = ByteBuffer.wrap(message);
@@ -108,6 +109,34 @@ public class TikTokWebsocketClient {
         }
     }
 
+    public void startWS2(String url) {
+        try {
+            var cookie = tikTokCookieJar.parseCookies();
+            System.out.println("WssIP: " + url);
+            System.out.println("Cookie: " + cookie);
+
+            var map = new HashMap<String, String>();
+            map.put("Cookie", cookie);
+
+            var client = new WebSocketClientTest(URI.create(url), new Draft_6455(), map, 1500,webResponseHandler);
+            client.connect();
+              /*
+            while (true) {
+                byte[] message = new byte[]{58, 2, 104, 98};
+                ByteBuffer buffer = ByteBuffer.wrap(message);
+                while (buffer.hasRemaining()) {
+                   // client.send(buffer);
+                    client.sendPing();
+                }
+                buffer.clear();
+                Thread.sleep(10);
+            }*/
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     public void stop() {
 
     }

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

@@ -0,0 +1,120 @@
+package io.github.jwdeveloper.tiktok.websocket;
+
+import com.google.protobuf.ByteString;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.handlers.WebResponseHandlerBase;
+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;
+import org.java_websocket.handshake.ServerHandshake;
+
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.util.Base64;
+import java.util.Map;
+import java.util.zip.GZIPInputStream;
+
+public class WebSocketClientTest extends WebSocketClient {
+
+    private boolean debbug = false;
+
+    private final WebResponseHandlerBase webResponseHandler;
+
+
+    public WebSocketClientTest(URI serverUri,
+                               Draft protocolDraft,
+                               Map<String, String> httpHeaders,
+                               int connectTimeout,
+                               WebResponseHandlerBase webResponseHandler) {
+        super(serverUri, protocolDraft, httpHeaders, connectTimeout);
+        this.webResponseHandler = webResponseHandler;
+    }
+
+    @Override
+    public void onMessage(ByteBuffer data) {
+        sendPing();
+        //System.out.println("onMessage Binary");
+        var bytes = new byte[data.remaining()];
+        data.get(bytes);
+        if(debbug)
+        {
+            var decoded = Base64.getEncoder().encodeToString(bytes);
+            // System.out.println(decoded);
+        }
+        handleBinary(bytes);
+    }
+
+    private void handleBinary(byte[] buffer) {
+        try {
+
+            var websocketMessage = WebcastWebsocketMessage.parseFrom(buffer);
+            if (websocketMessage.getBinary().isEmpty()) {
+                return;
+            }
+            try {
+                var response = WebcastResponse.parseFrom(websocketMessage.getBinary());
+                sendAckId(websocketMessage.getId());
+                webResponseHandler.handle(response);
+            } catch (Exception e) {
+               throw new TikTokLiveException("Unabel to read WebcastResponse", e);
+            }
+        } catch (Exception e) {
+           throw new TikTokLiveException("Unabel to read WebcastWebsocketMessage", e);
+        }
+    }
+
+
+    public byte[] unGunzipFile(ByteString byteString) {
+
+        try {
+
+            GZIPInputStream gZIPInputStream = new GZIPInputStream(byteString.newInput());
+
+
+            var bytes = gZIPInputStream.readAllBytes();
+
+            gZIPInputStream.close();
+
+
+            return bytes;
+
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+        return new byte[0];
+    }
+    private void sendAckId(long id) {
+        var serverInfo = WebcastWebsocketAck
+                .newBuilder()
+                .setType("ack")
+                .setId(id)
+                .build();
+        send(serverInfo.toByteString().asReadOnlyByteBuffer());
+    }
+
+
+
+    @Override
+    public void onOpen(ServerHandshake serverHandshake) {
+        System.out.println("onOpen");
+        sendPing();
+    }
+
+    @Override
+    public void onMessage(String s) {
+        sendPing();
+    }
+
+    @Override
+    public void onClose(int i, String s, boolean b) {
+        System.out.println("onClose");
+    }
+
+    @Override
+    public void onError(Exception e) {
+        System.out.println("error");
+        e.printStackTrace();
+    }
+}

Client/src/main/proto/tiktokSchema.proto

@@ -1,310 +0,0 @@
-syntax = "proto3";
-package TikTok;
-
-option java_package = "io.github.jwdeveloper.generated";
-option java_multiple_files = true;
-
-// Data structure from im/fetch/ response
-message WebcastResponse {
-  repeated Message messages = 1;
-  string cursor = 2;
-  int32 fetchInterval = 3;
-  int64 serverTimestamp = 4;
-  string internalExt = 5;
-  int32 fetchType = 6; // ws (1) or polling (2)
-  WebsocketParam wsParam = 7;
-  int32 heartbeatDuration = 8;
-  bool needAck = 9;
-  string wsUrl = 10;
-}
-
-message Message {
-  string type = 1;
-  bytes binary = 2;
-}
-
-message WebsocketParam {
-  string name = 1;
-  string value = 2;
-}
-
-// Message types depending on Message.tyoe
-message WebcastControlMessage {
-  int32 action = 2;
-}
-
-// Statistics like viewer count
-message WebcastRoomUserSeqMessage {
-  repeated TopUser topViewers = 2;
-  int32 viewerCount = 3;
-}
-
-message TopUser {
-  uint64 coinCount = 1;
-  User user = 2;
-}
-message WebcastChatMessage {
-  WebcastMessageEvent event = 1;
-  User user = 2;
-  string comment = 3;
-}
-
-message WebcastMemberMessage {
-  WebcastMessageEvent event = 1;
-  User user = 2;
-  int32 actionId = 10;
-}
-
-message WebcastGiftMessage {
-  WebcastMessageEvent event = 1;
-  int32 giftId = 2;
-  int32 repeatCount = 5;
-  User user = 7;
-  int32 repeatEnd = 9;
-  uint64 groupId = 11;
-  WebcastGiftMessageGiftDetails giftDetails = 15;
-  string monitorExtra = 22;
-  WebcastGiftMessageGiftExtra giftExtra = 23;
-}
-
-message WebcastGiftMessageGiftDetails {
-  WebcastGiftMessageGiftImage giftImage = 1;
-  string giftName = 16;
-  string describe = 2;
-  int32 giftType = 11;
-  int32 diamondCount = 12;
-}
-
-// Taken from https://github.com/Davincible/gotiktoklive/blob/da4630622bc586629a53faae64e8c53509af29de/proto/tiktok.proto#L57
-message WebcastGiftMessageGiftExtra {
-  uint64 timestamp = 6;
-  uint64 receiverUserId = 8;
-}
-
-message WebcastGiftMessageGiftImage {
-  string giftPictureUrl = 1;
-}
-
-
-// Battle start
-message WebcastLinkMicBattle {
-  repeated WebcastLinkMicBattleItems battleUsers = 10;
-}
-
-message WebcastLinkMicBattleItems {
-  WebcastLinkMicBattleGroup battleGroup = 2;
-}
-
-message WebcastLinkMicBattleGroup {
-  LinkUser user = 1;
-}
-
-
-// Battle status
-message WebcastLinkMicArmies {
-  repeated WebcastLinkMicArmiesItems battleItems = 3;
-  int32 battleStatus = 7;
-}
-
-message WebcastLinkMicArmiesItems {
-  uint64 hostUserId = 1;
-  repeated WebcastLinkMicArmiesGroup battleGroups = 2;
-}
-
-message WebcastLinkMicArmiesGroup {
-  repeated User users = 1;
-  int32 points = 2;
-}
-
-
-// Follow & share event
-message WebcastSocialMessage {
-  WebcastMessageEvent event = 1;
-  User user = 2;
-}
-
-// Like event (is only sent from time to time, not with every like)
-message WebcastLikeMessage {
-  WebcastMessageEvent event = 1;
-  User user = 5;
-  int32 likeCount = 2;
-  int32 totalLikeCount = 3;
-}
-
-// New question event
-message WebcastQuestionNewMessage {
-  QuestionDetails questionDetails = 2;
-}
-
-message QuestionDetails {
-  string questionText = 2;
-  User user = 5;
-}
-
-message WebcastMessageEvent {
-  uint64 msgId = 2;
-  uint64 createTime = 4;
-  WebcastMessageEventDetails eventDetails = 8;
-}
-
-// Contains UI information
-message WebcastMessageEventDetails {
-  string displayType = 1;
-  string label = 2;
-}
-
-// Source: Co-opted https://github.com/zerodytrash/TikTok-Livestream-Chat-Connector/issues/19#issuecomment-1074150342
-message WebcastLiveIntroMessage {
-  uint64 id = 2;
-  string description = 4;
-  User user = 5;
-}
-
-message SystemMessage {
-  string description = 2;
-}
-
-message WebcastInRoomBannerMessage {
-  string data = 2;
-}
-
-message RankItem {
-  string colour = 1;
-  uint64 id = 4;
-}
-
-message WeeklyRanking {
-  string type = 1;
-  string label = 2;
-  RankItem rank = 3;
-}
-
-message RankContainer {
-  WeeklyRanking rankings = 4;
-}
-
-message WebcastHourlyRankMessage {
-  RankContainer data = 2;
-}
-
-// Chat Emotes (Subscriber)
-message WebcastEmoteChatMessage {
-  User user = 2;
-  EmoteDetails emote = 3;
-}
-
-message EmoteDetails {
-  string emoteId = 1;
-  EmoteImage image = 2;
-}
-
-message EmoteImage {
-  string imageUrl = 1;
-}
-
-// Envelope (treasure boxes)
-// Taken from https://github.com/ThanoFish/TikTok-Live-Connector/blob/9b215b96792adfddfb638344b152fa9efa581b4c/src/proto/tiktokSchema.proto
-message WebcastEnvelopeMessage {
-  TreasureBoxData treasureBoxData = 2;
-  TreasureBoxUser treasureBoxUser = 1;
-}
-
-message TreasureBoxUser {
-  TreasureBoxUser2 user2 = 8;
-}
-
-message TreasureBoxUser2 {
-  repeated TreasureBoxUser3 user3 = 4;
-}
-
-message TreasureBoxUser3 {
-  TreasureBoxUser4 user4 = 21;
-}
-
-message TreasureBoxUser4 {
-  User user = 1;
-}
-
-message TreasureBoxData {
-  uint32 coins = 5;
-  uint32 canOpen = 6;
-  uint64 timestamp = 7;
-}
-
-// New Subscriber message
-message WebcastSubNotifyMessage {
-  WebcastMessageEvent event = 1;
-  User user = 2;
-  int32 exhibitionType = 3;
-  int32 subMonth = 4;
-  int32 subscribeType = 5;
-  int32 oldSubscribeStatus = 6;
-  int32 subscribingStatus = 8;
-}
-
-// ==================================
-// Generic stuff
-
-message User {
-  uint64 userId = 1;
-  string nickname = 3;
-  ProfilePicture profilePicture = 9;
-  string uniqueId = 38;
-  string secUid = 46;
-  repeated UserBadgesAttributes badges = 64;
-  uint64 createTime = 16;
-  string bioDescription = 5;
-  FollowInfo followInfo = 22;
-}
-
-message FollowInfo {
-  int32 followingCount = 1;
-  int32 followerCount = 2;
-  int32 followStatus = 3;
-  int32 pushStatus = 4;
-}
-
-message LinkUser {
-  uint64 userId = 1;
-  string nickname = 2;
-  ProfilePicture profilePicture = 3;
-  string uniqueId = 4;
-}
-
-message ProfilePicture {
-  repeated string urls = 1;
-}
-
-
-message UserBadgesAttributes {
-  int32 badgeSceneType = 3;
-  repeated UserImageBadge imageBadges = 20;
-  repeated UserBadge badges = 21;
-}
-
-message UserBadge {
-  string type = 2;
-  string name = 3;
-}
-
-message UserImageBadge {
-  int32 displayType = 1;
-  UserImageBadgeImage image = 2;
-}
-
-message UserImageBadgeImage {
-  string url = 1;
-}
-
-// Websocket incoming message structure
-message WebcastWebsocketMessage {
-  uint64 id = 2;
-  string type = 7;
-  bytes binary = 8;
-}
-
-// Websocket acknowledgment message
-message WebcastWebsocketAck {
-  uint64 id = 2;
-  string type = 7;
-}

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

@@ -0,0 +1,29 @@
+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/TikTokLiveTest.java

@@ -1,23 +1,84 @@
 package io.github.jwdeveloper.tiktok;
 
-import org.junit.jupiter.api.Test;
+
+import io.github.jwdeveloper.tiktok.events.messages.*;
+import org.junit.Test;
 
 import java.io.IOException;
 
-public class TikTokLiveTest
+public class TikTokLiveTest {
-{
+    public static String TEST_USER_SUBJECT = "tv_asahi_news";
-    public static String TEST_USER_SUBJECT = "live_interactive_";
 
 
     @Test
     public void ShouldConnect() throws IOException {
-        var client = TikTokLive.newClient(TEST_USER_SUBJECT).build();
+        var client = TikTokLive.newClient(TEST_USER_SUBJECT)
-        client.run();
+                .onConnected(this::onConnected)
-
+                .onDisconnected(this::onDisconnected)
-
+                .onRoomViewerData(this::onViewerData)
-
+                .onJoin(this::onJoin)
+                .onComment(this::onComment)
+                .onFollow(this::onFollow)
+                .onShare(this::onShare)
+                .onSubscribe(this::onSubscribe)
+                .onLike(this::onLike)
+                .onGiftMessage(this::onGiftMessage)
+                .onEmote(this::onEmote)
+                .buildAndRun();
         System.in.read();
 
     }
+    private void onConnected(TikTokConnectedEvent e) {
+        print("Connected");
+    }
+
+    private void onDisconnected(TikTokDisconnectedEvent e) {
+        print("Disconnected");
+    }
+
+    private void onViewerData(TikTokRoomViewerDataEvent e) {
+        print("Viewer count is:", e.getViewerCount());
+    }
+
+    private void onJoin(TikTokJoinEvent e) {
+        print(e.getUser().getUniqueId(), "joined!");
+    }
+
+    private void onComment(TikTokCommentEvent e) {
+        print(e.getUser().getUniqueId(), e.getText());
+    }
+
+    private void onFollow(TikTokFollowEvent e) {
+        print(e.getNewFollower().getUniqueId(), "followed!");
+    }
+
+    private void onShare(TikTokShareEvent e) {
+        print(e.getUser().getUniqueId(), "shared!");
+    }
+
+    private void onSubscribe(TikTokSubscribeEvent e) {
+        print(e.getNewSubscriber().getUniqueId(), "subscribed!");
+    }
+
+    private void onLike(TikTokLikeEvent e) {
+
+        print(e.getSender().getUniqueId(), "liked!");
+    }
+
+    private void onGiftMessage(TikTokGiftMessageEvent e) {
+        print(e.getSender().getUniqueId(), "sent", e.getAmount(), "x", e.getGift().getName());
+    }
+
+    private void onEmote(TikTokEmoteEvent e) {
+        print(e.getUser().getUniqueId(), "sent", e.getEmoteId());
+    }
+
+    private static void print(Object... messages) {
+        var sb = new StringBuilder();
+        for (var message : messages) {
+            sb.append(message).append(" ");
+        }
+        System.out.println(sb.toString());
+    }
 
 }

Client/src/test/resources/WebcastWebsocketMessage.bin

@@ -0,0 +1,32 @@
+	ŔĆł»›„Ö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

Tools/pom.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>TikTokLiveJava</artifactId>
+        <groupId>io.github.jwdeveloper.tiktok</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>Tools</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.22</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.22</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup</groupId>
+            <artifactId>javapoet</artifactId>
+            <version>1.13.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>0.9.12</version>
+        </dependency>
+        <dependency>
+            <groupId>io.github.jwdeveloper.tiktok</groupId>
+            <artifactId>API</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.github.jwdeveloper.tiktok</groupId>
+            <artifactId>Client</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.github.jwdeveloper.tiktok</groupId>
+            <artifactId>Client</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <maven.compiler.source>16</maven.compiler.source>
+        <maven.compiler.target>16</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

Tools/src/main/java/io/github/jwdeveloper/tiktok/EventsGeneratorRun.java

@@ -0,0 +1,45 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.tiktok.events_generator.EventGeneratorSettings;
+import io.github.jwdeveloper.tiktok.events_generator.EventsGenerator;
+
+import java.io.IOException;
+
+public class EventsGeneratorRun {
+
+    private static boolean lock = false;
+
+    //Run objects
+    public static void main(String[] args) throws IOException {
+
+        if(lock)
+        {
+            return;
+        }
+        //generatesObjects()
+       // generateEventsMessages();
+    }
+
+
+    private static void generatesEventsObjects() throws IOException {
+        var settings = new EventGeneratorSettings();
+        settings.setTikTokEvent(false);
+        settings.setInputDictionary("C:\\Users\\ja\\RiderProjects\\TikTokLiveSharp\\TikTokLiveSharp\\Events\\Objects");
+        settings.setOutputDictionary("C:\\Users\\ja\\IdeaProjects\\TikTokLiveJava\\API\\src\\main\\java\\io\\github\\jwdeveloper\\tiktok\\events\\objects");
+        var generator = new EventsGenerator();
+        generator.compile(settings);
+    }
+
+    private static void generateEventsMessages() throws IOException {
+        var settings = new EventGeneratorSettings();
+        settings.setTikTokEvent(true);
+        settings.setPrefix("TikTok");
+        settings.setEndFix("Event");
+        settings.setInputDictionary("C:\\Users\\ja\\RiderProjects\\TikTokLiveSharp\\TikTokLiveSharp\\Events\\Messages");
+        settings.setOutputDictionary("C:\\Users\\ja\\IdeaProjects\\TikTokLiveJava\\API\\src\\main\\java\\io\\github\\jwdeveloper\\tiktok\\events\\messages");
+        var generator = new EventsGenerator();
+        generator.compile(settings);
+    }
+
+
+}

Tools/src/main/java/io/github/jwdeveloper/tiktok/EventsInterfaceGeneratorRun.java

@@ -0,0 +1,20 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.tiktok.events_generator.EventGeneratorSettings;
+import io.github.jwdeveloper.tiktok.intefacee.EventsInterfaceGenerator;
+
+import java.io.IOException;
+
+public class EventsInterfaceGeneratorRun
+{
+    public static void main(String[] args) throws IOException {
+        var settings = new EventGeneratorSettings();
+        settings.setTikTokEvent(true);
+        settings.setPrefix("TikTok");
+        settings.setEndFix("Event");
+        settings.setInputDictionary("C:\\Users\\ja\\RiderProjects\\TikTokLiveSharp\\TikTokLiveSharp\\Events\\Messages");
+        settings.setOutputDictionary("C:\\Users\\ja\\IdeaProjects\\TikTokLiveJava\\API\\src\\main\\java\\io\\github\\jwdeveloper\\tiktok\\events\\messages");
+        var generator = new EventsInterfaceGenerator();
+        generator.compile(settings);
+    }
+}