Changes:

- TikTokHttpResponseEvent
  - Fixed User attributes in CommentEvent
  - Redesign .onMapper method

.gitignore

@@ -1,61 +1,85 @@
-# Project exclude paths
-/API/target/
-/Client/target/
-*.db
+backend-infrastructure/.aws-sam
 
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Created by https://www.gitignore.io/api/osx,linux,python,windows,pycharm,visualstudiocode
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### OSX ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 
-# User-specific stuff
+# User-specific stuff:
 .idea/**/workspace.xml
 .idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
+.idea/dictionaries
+.idea/
 
-# AWS User-specific
-.idea/**/aws.xml
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
+# Sensitive or high-churn files:
 .idea/**/dataSources/
 .idea/**/dataSources.ids
+.idea/**/dataSources.xml
 .idea/**/dataSources.local.xml
 .idea/**/sqlDataSources.xml
 .idea/**/dynamic.xml
 .idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
 
-# Gradle
+# Gradle:
 .idea/**/gradle.xml
 .idea/**/libraries
 
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn.  Uncomment if using
-# auto-import.
-# .idea/artifacts
-# .idea/compiler.xml
-# .idea/jarRepositories.xml
-# .idea/modules.xml
-# .idea/*.iml
-# .idea/modules
-# *.iml
-# *.ipr
-
 # CMake
-cmake-build-*/
+cmake-build-debug/
 
-# Mongo Explorer plugin
+# Mongo Explorer plugin:
 .idea/**/mongoSettings.xml
 
-# File-based project format
+## File-based project format:
 *.iws
 
+## Plugin-specific files:
+
 # IntelliJ
-out/
+/out/
 
 # mpeltonen/sbt-idea plugin
 .idea_modules/
@@ -66,8 +90,8 @@ atlassian-ide-plugin.xml
 # Cursive Clojure plugin
 .idea/replstate.xml
 
-# SonarLint plugin
-.idea/sonarlint/
+# Ruby plugin and RubyMine
+/.rakeTasks
 
 # Crashlytics plugin (for Android Studio and IntelliJ)
 com_crashlytics_export_strings.xml
@@ -75,69 +99,150 @@ crashlytics.properties
 crashlytics-build.properties
 fabric.properties
 
-# Editor-based Rest Client
-.idea/httpRequests
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
 
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-/.idea/.gitignore
-/.idea/.name
-/.idea/compiler.xml
-/TestApplication/target/classes/io/github/jwdeveloper/tiktok/ConfigurationExample.class
-/TestApplication/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
-/TestApplication/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst
-/Tools/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
-/Tools/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst
-/Tools-EventsCollector/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
-/Tools-ReadmeGenerator/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
-/Tools-ReadmeGenerator/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst
-/.idea/encodings.xml
-/Tools-ReadmeGenerator/target/classes/io/github/jwdeveloper/tiktok/EventsListGenerator$EventTypeComparator.class
-/Tools-ReadmeGenerator/target/classes/io/github/jwdeveloper/tiktok/EventsListGenerator.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/tables/ExceptionInfoModel.class
-/Tools/target/classes/io/github/jwdeveloper/tiktok/utils/FilesUtility.class
-/TestApplication/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
-/TestApplication/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst
-/Tools/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
-/Tools/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst
-/Tools-EventsCollector/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
-/Tools-ReadmeGenerator/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
-/Tools-ReadmeGenerator/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst
-/.idea/jarRepositories.xml
-/TestApplication/target/classes/io/github/jwdeveloper/tiktok/ListenerExample$CustomListener.class
-/TestApplication/target/classes/io/github/jwdeveloper/tiktok/ListenerExample.class
-/Tools-ReadmeGenerator/target/classes/io/github/jwdeveloper/tiktok/LiveClientMethodsGenerator.class
-/TestApplication/target/classes/io/github/jwdeveloper/tiktok/Main.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/Main.class
-/Tools-ReadmeGenerator/target/classes/io/github/jwdeveloper/tiktok/Main.class
-/.idea/misc.xml
-/Tools-ReadmeGenerator/src/main/resources/output.md
-/Tools-ReadmeGenerator/target/classes/output.md
-/TestApplication/target/maven-archiver/pom.properties
-/Tools/target/maven-archiver/pom.properties
-/Tools-EventsCollector/target/maven-archiver/pom.properties
-/Tools-ReadmeGenerator/target/maven-archiver/pom.properties
-/.idea/inspectionProfiles/Project_Default.xml
-/Tools/target/classes/io/github/jwdeveloper/tiktok/protocol/ProtocolGenerator.class
-/Tools-ReadmeGenerator/target/classes/io/github/jwdeveloper/tiktok/ReadmeGenerator.class
-/TestApplication/target/classes/io/github/jwdeveloper/tiktok/SimpleExample.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/db/SqlConsts.class
-/Tools-ReadmeGenerator/target/classes/template.md
-/Tools/target/classes/io/github/jwdeveloper/tiktok/utils/TemplateUtility.class
-/TestApplication/target/TestApplication-0.0.18-Release.jar
-/TestApplication/target/TestApplication-0.0.18-Release-all.jar
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/db/TikTokDatabase.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/tables/TikTokErrorModel$TikTokErrorModelBuilder.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/tables/TikTokErrorModel.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/db/TikTokErrorModelDAO.class
-/target/TikTokLiveJava-0.0.18-Release-all.pom
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/tables/TikTokMessageModel$TikTokMessageModelBuilder.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/tables/TikTokMessageModel.class
-/Tools-EventsCollector/target/classes/io/github/jwdeveloper/tiktok/tools/collector/db/TikTokMessageModelDAO.class
-/Tools/target/Tools-0.0.18-Release.jar
-/Tools/target/Tools-0.0.18-Release-all.jar
-/Tools-EventsCollector/target/Tools-EventsCollector-0.0.18-Release.jar
-/Tools-EventsCollector/target/Tools-EventsCollector-0.0.18-Release-all.jar
-/Tools-ReadmeGenerator/target/Tools-ReadmeGenerator-0.0.18-Release.jar
-/Tools-ReadmeGenerator/target/Tools-ReadmeGenerator-0.0.18-Release-all.jar
-/.idea/vcs.xml
+*.iml
+modules.xml
+.idea/misc.xml
+*.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule.*
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+**/target/
+# Build folder
+
+*/build/*
+
+# End of https://www.gitignore.io/api/osx,linux,python,windows,pycharm,visualstudiocode
+/python-app-backend/samconfig.toml
+/java-app-backend/BackendFunction/dependency-reduced-pom.xml

.idea/protoeditor.xml

@@ -64,6 +64,9 @@
         <ImportPathEntry>
           <option name="location" value="file://$PROJECT_DIR$/API/src/main/proto" />
         </ImportPathEntry>
+        <ImportPathEntry>
+          <option name="location" value="file://$USER_HOME$/AppData/Local/JetBrains/IntelliJIdea2022.3/protoeditor" />
+        </ImportPathEntry>
       </list>
     </option>
     <option name="descriptorPath" value="google/protobuf/descriptor.proto" />

API/pom.xml

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

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

@@ -52,16 +52,11 @@ public class ClientSettings {
      */
     private Duration retryConnectionTimeout;
 
-    /**
-     * Whether to handle Events received from Room when Connecting
-     */
-    private boolean handleExistingEvents;
-
     /**
      * Whether to print Logs to Console
      */
 
-    private boolean printToConsole;
+    private boolean printToConsole = true;
     /**
      * LoggingLevel for Logs
      */
@@ -69,7 +64,7 @@ public class ClientSettings {
 
 
     /**
-     *  Optional: Use it if you need to change TikTok live hostname in builder
+     * Optional: Use it if you need to change TikTok live hostname in builder
      */
     private String hostName;
 

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

@@ -57,7 +57,6 @@ public class Constants {
         var clientSettings = new ClientSettings();
         clientSettings.setTimeout(Duration.ofSeconds(DEFAULT_TIMEOUT));
         clientSettings.setClientLanguage("en-US");
-        clientSettings.setHandleExistingEvents(true);
         clientSettings.setRetryOnConnectionFailure(false);
         clientSettings.setRetryConnectionTimeout(Duration.ofSeconds(1));
         clientSettings.setPrintToConsole(false);

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

@@ -30,3 +30,6 @@ public @interface EventMeta
 {
      EventType eventType();
 }
+
+
+

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

@@ -26,7 +26,7 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
 @Retention(RetentionPolicy.RUNTIME)
-public @interface TikTokEventHandler
+public @interface TikTokEventObserver
 {
 
 }

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

@@ -20,18 +20,17 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-package io.github.jwdeveloper.tiktok.tools.collector.tables;
+package io.github.jwdeveloper.tiktok.data.dto;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.Value;
+
+import java.time.Duration;
 
 @Data
-public class TikTokResponseModel
+@AllArgsConstructor
+public class MessageMetaData
 {
-    private Integer id;
-
-    private String hostName;
-
-    private String response;
-
-    private String createdAt;
+    private Duration handlingTime;
 }

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.data.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class TikTokUserInfo
+{
+    UserStatus userStatus;
+
+    String roomId;
+
+    public enum UserStatus
+    {
+        NotFound,
+        Offline,
+        LivePaused,
+        Live
+    }
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.data.events;
+
+import io.github.jwdeveloper.tiktok.annotations.EventMeta;
+import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
+
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import lombok.Data;
+
+
+@Data
+@EventMeta(eventType = EventType.Message)
+public class CustomEvent extends TikTokHeaderEvent {
+    private final User user;
+    private final String title;
+
+    public CustomEvent(User user, String title) {
+        this.user = user;
+        this.title = title;
+    }
+}

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

@@ -47,11 +47,11 @@ public class TikTokCommentEvent extends TikTokHeaderEvent {
 
     public TikTokCommentEvent(WebcastChatMessage msg) {
         super(msg.getCommon());
-        user = User.map(msg.getUser());
+        user = User.map(msg.getUser(),msg.getUserIdentity());
         text = msg.getContent();
         visibleToSender = msg.getVisibleToSender();
         getUserLanguage = msg.getContentLanguage();
-        mentionedUser = User.map(msg.getAtUser(),msg.getUserIdentity());
+        mentionedUser = User.map(msg.getAtUser());
         pictures = msg.getEmotesListList().stream().map(e -> Picture.map(e.getEmote().getImage())).toList();
     }
 }

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

@@ -34,18 +34,10 @@ import java.util.List;
 @Getter
 @EventMeta(eventType = EventType.Message)
 public class TikTokLinkEvent extends TikTokHeaderEvent {
-    private final String token;
 
-    private User user;
-
-    private final List<User> otherUsers;
 
     public TikTokLinkEvent(WebcastLinkMessage msg) {
         super(msg.getCommon());
-        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/data/events/TikTokLiveUnpausedEvent.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.data.events;
+
+import io.github.jwdeveloper.tiktok.annotations.EventMeta;
+import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+
+
+@EventMeta(eventType = EventType.Message)
+public class TikTokLiveUnpausedEvent extends TikTokEvent {
+}

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

@@ -26,7 +26,9 @@ import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.data.models.users.UserAttribute;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastMemberMessage;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSubNotifyMessage;
 import lombok.Getter;
 
 /**
@@ -34,16 +36,20 @@ import lombok.Getter;
  */
 @Getter
 @EventMeta(eventType = EventType.Message)
-public class TikTokSubscribeEvent extends TikTokHeaderEvent {
-  private User user;
+public class TikTokSubscribeEvent extends TikTokHeaderEvent
+{
+    private final User user;
 
-  public TikTokSubscribeEvent(WebcastMemberMessage msg) {
-    super(msg.getCommon());
-
-    if(msg.hasUser())
-    {
-      user = new User(msg.getUser());
+    public TikTokSubscribeEvent(WebcastMemberMessage msg) {
+        super(msg.getCommon());
+        user = User.map(msg.getUser());
+        user.addAttribute(UserAttribute.Subscriber);
+    }
+
+    public TikTokSubscribeEvent(WebcastSubNotifyMessage msg) {
+        super(msg.getCommon());
+        user = User.map(msg.getUser());
+        user.addAttribute(UserAttribute.Subscriber);
     }
-  }
 
 }

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

@@ -20,36 +20,52 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-package io.github.jwdeveloper.tiktok.data.events.room;
+package io.github.jwdeveloper.tiktok.data.events.envelop;
 
 import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
-import io.github.jwdeveloper.tiktok.data.models.RankingUser;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastRoomUserSeqMessage;
-import lombok.Getter;
+import io.github.jwdeveloper.tiktok.data.models.Text;
 
-import java.util.List;
-import java.util.stream.Collectors;
+import io.github.jwdeveloper.tiktok.data.models.chest.Chest;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastEnvelopeMessage;
+import lombok.Value;
+
+import java.util.Date;
 
 
-
-@Getter
 @EventMeta(eventType = EventType.Message)
-public class TikTokRoomUserInfoEvent extends TikTokHeaderEvent {
-    private final int totalUsers;
+@Value
+public class TikTokChestEvent extends TikTokHeaderEvent {
 
     /**
-     * Only top 5 users in ranking has detailed data
-     * rest has only ID
+     *  Chest target
      */
-    private final List<RankingUser> usersRanking;
-    public TikTokRoomUserInfoEvent(WebcastRoomUserSeqMessage msg) {
-        super(msg.getCommon());
-        totalUsers = msg.getTotalUser();
-        usersRanking = msg.getRanksListList().stream().map(RankingUser::new)
-                .sorted((ru1, ru2) -> Integer.compare(ru2.getScore(), ru1.getScore()))
-                .collect(Collectors.toList());
-    }
+    Chest chest;
 
+    /**
+     * User that send a chest
+     */
+    User user;
+
+    /**
+     * Time when chest has been open
+     */
+    Date openedAt;
+
+    public TikTokChestEvent(Chest chest, WebcastEnvelopeMessage msg) {
+        super(msg.getCommon());
+        this.chest = chest;
+
+        var text = Text.map(msg.getCommon().getDisplayText());
+        var userPiece = (Text.UserTextPiece) text.getTextPieces().get(0);
+        user = userPiece.getUser();
+
+
+        var envelopInfo = msg.getEnvelopeInfo();
+
+        openedAt = new Date(envelopInfo.getUnpackAt());
+
+    }
 }

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

@@ -26,28 +26,34 @@ package io.github.jwdeveloper.tiktok.data.events.gift;
 import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
+import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
 import io.github.jwdeveloper.tiktok.data.models.gifts.GiftSendType;
 import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import lombok.Getter;
 
+import java.util.ArrayList;
 
-/*
+
+/**
  * Triggered when user sends gifts that has
- *  no combo (most of expensive gifts)
- *  or if combo has finished
+ * no combo (most of expensive gifts)
+ * or if combo has finished
  */
 @EventMeta(eventType = EventType.Message)
 @Getter
 public class TikTokGiftEvent extends TikTokHeaderEvent {
     private final Gift gift;
     private final User user;
+    private final User toUser;
     private final int combo;
+
     public TikTokGiftEvent(Gift gift, WebcastGiftMessage msg) {
         super(msg.getCommon());
         this.gift = gift;
         user = User.map(msg.getUser(), msg.getUserIdentity());
+        toUser = new User(msg.getUserGiftReciever().getUserId(), "", "", new Picture(""), 0, 0, new ArrayList<>());
         combo = msg.getComboCount();
     }
-}
+}

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

@@ -0,0 +1,20 @@
+package io.github.jwdeveloper.tiktok.data.events.http;
+
+import io.github.jwdeveloper.tiktok.annotations.EventMeta;
+import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.models.http.HttpData;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+@EventMeta(eventType = EventType.Debug)
+public class TikTokHttpResponseEvent extends TikTokEvent
+{
+    String url;
+
+    HttpData response;
+
+    HttpData request;
+}

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

@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.data.events.room;
-
-import io.github.jwdeveloper.tiktok.annotations.EventMeta;
-import io.github.jwdeveloper.tiktok.annotations.EventType;
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokHeaderEvent;
-import io.github.jwdeveloper.tiktok.data.models.users.User;
-import io.github.jwdeveloper.tiktok.data.models.users.UserAttribute;
-import io.github.jwdeveloper.tiktok.messages.webcast.RoomMessage;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLiveIntroMessage;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastRoomMessage;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSystemMessage;
-import lombok.Getter;
-
-@Getter
-@EventMeta(eventType = EventType.Message)
-public class TikTokRoomEvent extends TikTokHeaderEvent
-{
-    private User hostUser;
-    private String hostLanguage;
-    private final String welcomeMessage;
-
-    public TikTokRoomEvent(WebcastRoomMessage msg) {
-        super(msg.getCommon());
-        welcomeMessage = msg.getContent();
-    }
-
-    public TikTokRoomEvent(RoomMessage msg) {
-        super(msg.getCommon());
-        welcomeMessage = msg.getContent();
-    }
-
-    public TikTokRoomEvent(WebcastSystemMessage msg) {
-        super(msg.getCommon());
-        welcomeMessage = msg.getMessage();
-    }
-
-    public TikTokRoomEvent(WebcastLiveIntroMessage msg) {
-        super(msg.getCommon());
-        hostUser = User.map(msg.getHost());
-        hostUser.addAttribute(UserAttribute.LiveHost);
-        welcomeMessage = msg.getContent();
-        hostLanguage = msg.getLanguage();
-    }
-
-}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.data.events.room;
+
+import io.github.jwdeveloper.tiktok.annotations.EventMeta;
+import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+
+/*
+Triggered when LiveRoomInfo got updated such as likes, viewers, ranking ....
+ */
+@Getter
+@AllArgsConstructor
+@EventMeta(eventType = EventType.Message)
+public class TikTokRoomInfoEvent extends TikTokEvent
+{
+    LiveRoomInfo roomInfo;
+}

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

@@ -24,7 +24,9 @@ package io.github.jwdeveloper.tiktok.data.events.websocket;
 
 import io.github.jwdeveloper.tiktok.annotations.EventMeta;
 import io.github.jwdeveloper.tiktok.annotations.EventType;
+import io.github.jwdeveloper.tiktok.data.dto.MessageMetaData;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -34,22 +36,32 @@ import java.time.Duration;
 
 
 /**
- * Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
+ * Triggered every time TikTok sends data. Data incoming as protobuf message.
+ * You can deserialize the binary object depending on the use case.
  */
 @Getter
 @AllArgsConstructor
 @EventMeta(eventType = EventType.Debug)
-public class TikTokWebsocketMessageEvent extends TikTokEvent
-{
-    private TikTokEvent event;
+public class TikTokWebsocketMessageEvent extends TikTokEvent {
 
+    /*
+     * Original message that is coming from TikTok
+     *  message.method - Name of message type, for example "WebcastGiftMessage"
+     *  message.payload - Bytes array that contains actual data of message.
+     *                    Example of parsing, WebcastGiftMessage giftMessage = WebcastGiftMessage.parseFrom(message.getPayload());
+     */
     private WebcastResponse.Message message;
 
-    private MetaData metaData;
+    /*
+     * TikTokLiveJava event that was created from TikTok message data
+     * Example: TikTokGiftEvent
+     */
+    private TikTokEvent event;
+
+    /*
+     * Metadata information about mapping message to event, such as time and stuff
+     */
+    private MessageMetaData metaData;
+
 
-    @Value
-    public static class MetaData
-    {
-        Duration handlingTime;
-    }
 }

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

@@ -39,4 +39,9 @@ public class TikTokWebsocketUnhandledMessageEvent extends TikTokUnhandledEvent<W
     public TikTokWebsocketUnhandledMessageEvent(WebcastResponse.Message data) {
         super(data);
     }
+
+    public WebcastResponse.Message getMessage()
+    {
+        return this.getData();
+    }
 }

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

@@ -51,7 +51,7 @@ public class Picture {
     public static Picture map(io.github.jwdeveloper.tiktok.messages.data.Image profilePicture) {
 
         var index = profilePicture.getUrlListCount() - 1;
-        if (index <= 0) {
+        if (index < 0) {
             return new Picture("");
         }
         var url = profilePicture.getUrlList(index);

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

@@ -29,6 +29,7 @@ import lombok.Value;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.regex.Pattern;
 
 @Getter
@@ -45,6 +46,12 @@ public class Text {
         this.value = computeValue();
     }
 
+
+    public <T extends TextPiece> Optional<TextPiece> getTextPiece(Class<T> type)
+    {
+        return textPieces.stream().filter(e -> e.getClass().equals(type)).findFirst();
+    }
+
     public static Text map(io.github.jwdeveloper.tiktok.messages.data.Text input) {
         var pieces = input.getPiecesListList().stream().map(Text::mapTextPiece).toList();
         return new Text(input.getKey(), input.getDefaultPattern(), pieces);
@@ -98,6 +105,7 @@ public class Text {
         }
     }
 
+    @Value
     public static class UserTextPiece extends TextPiece {
         User user;
 

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/chest/Chest.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.data.models.chest;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class Chest {
+
+    /**
+     * Total diamonds inside the chest
+     */
+    int totalDiamonds;
+
+    /**
+     * Total users participated in chest
+     */
+    int totalUsers;
+
+
+
+}

API/src/main/java/io/github/jwdeveloper/tiktok/data/models/http/HttpData.java

@@ -0,0 +1,60 @@
+package io.github.jwdeveloper.tiktok.data.models.http;
+
+import lombok.Data;
+
+import java.net.URI;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.*;
+
+@Data
+public class HttpData {
+    String url;
+    String method;
+    Map<String, List<String>> headers = new TreeMap<>();
+    Map<String, String> parameters = new TreeMap<>();
+    int status;
+    String body = "";
+
+
+    public static HttpData map(HttpRequest request) {
+        var data = new HttpData();
+        data.setUrl(request.uri().getPath());
+        data.setMethod(request.method());
+        data.setParameters(extractQueryParams(request.uri()));
+        data.setStatus(200);
+        if (request.bodyPublisher().isPresent()) {
+            data.setBody(request.bodyPublisher().get().toString());
+        }
+        data.setHeaders(Collections.unmodifiableMap(request.headers().map()));
+        return data;
+    }
+
+    public static HttpData map(HttpResponse<String> response) {
+        var data = new HttpData();
+        data.setUrl(response.uri().getPath());
+        data.setMethod(response.request().method());
+        data.setParameters(extractQueryParams(response.uri()));
+        data.setStatus(200);
+        data.setBody(response.body());
+        data.setHeaders(Collections.unmodifiableMap(response.headers().map()));
+        return data;
+    }
+
+
+    private static Map<String, String> extractQueryParams(URI uri) {
+        Map<String, String> params = new HashMap<>();
+        String query = uri.getQuery();
+        if (query != null && !query.isEmpty()) {
+            for (String param : query.split("&")) {
+                String[] keyValue = param.split("=");
+                if (keyValue.length > 1) {
+                    params.put(keyValue[0], keyValue[1]);
+                } else {
+                    params.put(keyValue[0], ""); // Empty value for parameter without explicit value
+                }
+            }
+        }
+        return params;
+    }
+}

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

@@ -45,6 +45,8 @@ public class User {
     @Getter(AccessLevel.NONE)
     private Set<UserAttribute> attributes;
 
+
+
     public List<UserAttribute> getAttributes() {
         return attributes.stream().toList();
     }
@@ -107,6 +109,23 @@ public class User {
         this.attributes = new HashSet<>();
     }
 
+    public User(Long id,
+                String name,
+                String profileName,
+                Picture picture,
+                long following,
+                long followers,
+                List<Badge> badges) {
+        this.id = id;
+        this.name = name;
+        this.profileName = profileName;
+        this.picture = picture;
+        this.following = following;
+        this.followers = followers;
+        this.badges = badges;
+        this.attributes = new HashSet<>();
+    }
+
     public User(Long userId,
                 String nickName) {
         this.id = userId;

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

@@ -26,15 +26,20 @@ package io.github.jwdeveloper.tiktok.exceptions;
 /**
  * Happens when incoming data from TikTok can not be mapped to TikTokEvent's
  */
-public class TikTokMessageMappingException extends TikTokLiveException
-{
-    public TikTokMessageMappingException(Class<?> inputClazz, Class<?> outputClass, Throwable throwable)
-    {
-        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + " to class " + outputClass.getSimpleName(),throwable);
+public class TikTokMessageMappingException extends TikTokLiveException {
+    public TikTokMessageMappingException(Class<?> inputClazz, Class<?> outputClass, Throwable throwable) {
+        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + " to class " + outputClass.getSimpleName(), throwable);
     }
 
-    public TikTokMessageMappingException(Class<?> inputClazz, Class<?> outputClass, String message)
-    {
-        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + " to class " + outputClass.getSimpleName()+": "+message);
+    public TikTokMessageMappingException(Class<?> inputClazz, Class<?> outputClass, String message) {
+        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + " to class " + outputClass.getSimpleName() + ": " + message);
+    }
+
+    public TikTokMessageMappingException(Class<?> inputClazz, String message, Throwable throwable) {
+        super("Unable to handle mapping from class: " + inputClazz.getSimpleName() + ": " + message, throwable);
+    }
+
+    public TikTokMessageMappingException(String message, Throwable throwable) {
+        super( message, throwable);
     }
 }

API/src/main/java/io/github/jwdeveloper/tiktok/http/TikTokHttpRequest.java

@@ -31,4 +31,5 @@ public interface TikTokHttpRequest {
     String get(String url);
 
     String post(String url);
+
 }

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

@@ -22,6 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok.live;
 
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.listener.ListenersManager;
 import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
 
@@ -55,6 +56,11 @@ public interface LiveClient {
     void disconnect();
 
 
+    /**
+     * You to manually trigger event
+     */
+     void publishEvent(TikTokEvent event);
+
     /**
      * Get information about gifts
      */

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

@@ -22,14 +22,31 @@
  */
 package io.github.jwdeveloper.tiktok.live;
 
+import io.github.jwdeveloper.tiktok.data.models.RankingUser;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.models.ConnectionState;
 
+import java.util.List;
+
 public interface LiveRoomInfo
 {
+     /**
+      *
+      * @return get current count of viewers of live
+      */
      int getViewersCount();
+
+     /**
+      *
+      * @return get total current count of viewers since beginning of live
+      */
+     int getTotalViewersCount();
      int getLikesCount();
      boolean isAgeRestricted();
      String getRoomId();
      String getHostName();
+     String getTitle();
+     User getHostUser();
+     List<RankingUser> getUsersRanking();
      ConnectionState getConnectionState();
 }

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

@@ -22,16 +22,19 @@
  */
 package io.github.jwdeveloper.tiktok.live;
 
+import io.github.jwdeveloper.tiktok.data.models.users.User;
 import lombok.Data;
 
 @Data
 public class LiveRoomMeta {
 
     private LiveRoomStatus status;
-
     private boolean ageRestricted;
-
-
+    private String titie;
+    private int likeCount;
+    private int totalViewers;
+    private int viewers;
+    private User host;
 
     public enum LiveRoomStatus
     {

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

@@ -26,8 +26,8 @@ import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomUserInfoEvent;
+import io.github.jwdeveloper.tiktok.data.events.http.TikTokHttpResponseEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokFollowEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
@@ -39,52 +39,141 @@ import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandl
 
 public interface EventsBuilder<T> {
 
-    T onRoom(EventConsumer<TikTokRoomEvent> event);
+    /**
+     * Invoked whenever specified event is triggered
+     *
+     * @param eventClass event class
+     * @param action     action
+     */
+    <E extends TikTokEvent> T onEvent(Class<E> eventClass, EventConsumer<E> action);
 
-    T onRoomUserInfo(EventConsumer<TikTokRoomUserInfoEvent> event);
 
-    T onComment(EventConsumer<TikTokCommentEvent> event);
+    /**
+     * Invoked whenever any event is triggered
+     *
+     * @param action
+     * @return
+     */
+    T onEvent(EventConsumer<TikTokEvent> action);
 
-    T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event);
+    /**
+     * Invoked when information about room (live) got updated such as viewer count, etc..
+     *
+     * @param action
+     * @return
+     */
+    T onRoomInfo(EventConsumer<TikTokRoomInfoEvent> action);
 
-    T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event);
+    /**
+     * Invoked when someone send message to chat
+     *
+     * @param action
+     * @return
+     */
+    T onComment(EventConsumer<TikTokCommentEvent> action);
 
-    T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event);
 
-    T onGiftCombo(EventConsumer<TikTokGiftComboEvent> event);
-    T onGift(EventConsumer<TikTokGiftEvent> event);
+    /**
+     * Invoked when TikTokLiveJava makes http request and getting response
+     *
+     * @param action
+     * @return
+     */
+    T onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action);
 
-    T onQuestion(EventConsumer<TikTokQuestionEvent> event);
+    /**
+     * Invoked when TikTok protocolBuffer data "message" was successfully mapped to event
+     * events contains protocol-buffer "Message"  and  TikTokLiveJava "Event"
+     *
+     * @param action
+     * @return
+     */
+    T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> action);
 
-    T onSubscribe(EventConsumer<TikTokSubscribeEvent> event);
+    /**
+     * Invoked when there was not found event mapper for TikTok protocolBuffer data "message"
+     *
+     * @param action
+     * @return
+     */
+    T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> action);
 
-    T onFollow(EventConsumer<TikTokFollowEvent> event);
+    /**
+     * Invoked every time TikTok sends protocolBuffer data to websocket
+     * Response contains list of messages that are later mapped to events
+     * @param action
+     * @return
+     */
+    T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> action);
 
-    T onLike(EventConsumer<TikTokLikeEvent> event);
 
-    T onEmote(EventConsumer<TikTokEmoteEvent> event);
+    /**
+     * Invoked for gifts that has no combo, or when combo finishes
+     * @param action
+     * @return
+     */
+    T onGift(EventConsumer<TikTokGiftEvent> action);
 
-    T onJoin(EventConsumer<TikTokJoinEvent> event);
+    /**
+     * Invoked for gifts that has combo options such as roses
+     * @param action
+     * @return
+     */
+    T onGiftCombo(EventConsumer<TikTokGiftComboEvent> action);
 
-    T onShare(EventConsumer<TikTokShareEvent> event);
-    T onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event);
 
-    T onLivePaused(EventConsumer<TikTokLivePausedEvent> event);
+    T onQuestion(EventConsumer<TikTokQuestionEvent> action);
 
-    T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event);
+    T onSubscribe(EventConsumer<TikTokSubscribeEvent> action);
 
-    T onConnected(EventConsumer<TikTokConnectedEvent> event);
+    T onFollow(EventConsumer<TikTokFollowEvent> action);
 
-    T onReconnecting(EventConsumer<TikTokReconnectingEvent> event);
+    T onLike(EventConsumer<TikTokLikeEvent> action);
 
-    T onDisconnected(EventConsumer<TikTokDisconnectedEvent> event);
+    T onEmote(EventConsumer<TikTokEmoteEvent> action);
 
-    T onError(EventConsumer<TikTokErrorEvent> event);
+    T onJoin(EventConsumer<TikTokJoinEvent> action);
 
-    T onEvent(EventConsumer<TikTokEvent> event);
+    T onShare(EventConsumer<TikTokShareEvent> action);
+
+    T onLivePaused(EventConsumer<TikTokLivePausedEvent> action);
+
+    T onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> action);
+
+    T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> action);
+
+    /**
+     * Invoked when client has been successfully connected to live
+     * @param action
+     * @return
+     */
+    T onConnected(EventConsumer<TikTokConnectedEvent> action);
+
+    /**
+     * Invoked when client tries to reconnect
+     * @param action
+     * @return
+     */
+    T onReconnecting(EventConsumer<TikTokReconnectingEvent> action);
+
+    /**
+     * Invoked when client disconnected
+     * @param action
+     * @return
+     */
+    T onDisconnected(EventConsumer<TikTokDisconnectedEvent> action);
+
+    /**
+     * Invoked when exception was throed inside client or event handler
+     * @param action
+     * @return
+     */
+    T onError(EventConsumer<TikTokErrorEvent> action);
 
 
     // TODO Figure out how those events works
+    //  T onChest(EventConsumer<TikTokChestEvent> event);
+
     //T onLinkMicFanTicket(TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event);
 
     //T onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event);

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

@@ -23,20 +23,60 @@
 package io.github.jwdeveloper.tiktok.live.builder;
 
 import io.github.jwdeveloper.tiktok.ClientSettings;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.mappers.TikTokMapper;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
-    LiveClientBuilder configure(Consumer<ClientSettings> consumer);
 
+    /**
+     * This method is triggered after default mappings are registered
+     * It could be used to OVERRIDE behaviour of mappings and implement custom behaviour
+     *
+     * Be aware if for example you override WebcastGiftEvent, onGiftEvent() will not be working
+     *
+     * @param onCustomMappings lambda method
+     * @return
+     */
+    LiveClientBuilder onMapping(Consumer<TikTokMapper> onCustomMappings);
+
+
+    /**
+     * Configuration of client settings
+     * @see ClientSettings
+     * @param onConfigure
+     * @return
+     */
+    LiveClientBuilder configure(Consumer<ClientSettings> onConfigure);
+
+    /**
+     * @see TikTokEventListener
+     * Adding events listener class, its fancy way to register events without using lamda method
+     * but actual method in class that implements TikTokEventListener
+     * @return
+     */
     LiveClientBuilder addListener(TikTokEventListener listener);
 
+    /**
+     *
+     * @return LiveClient object
+     */
     LiveClient build();
 
+    /**
+     *
+     * @return LiveClient object and connects to TikTok live
+     */
     LiveClient buildAndConnect();
 
+    /**
+     *
+     * @return LiveClient object and connects to TikTok live asynchronously
+     */
     CompletableFuture<LiveClient> buildAndConnectAsync();
 }

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.mappers;
+
+import com.google.protobuf.GeneratedMessageV3;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingAction;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+
+import java.util.function.Function;
+
+public interface TikTokMapper {
+
+    /**
+     * * if mapper is not found for messageName, TikTokLiveException is thrown
+     *
+     * @param messageName
+     * @return TikTokMapperModel
+     */
+    TikTokMapperModel forMessage(String messageName);
+
+    TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName);
+
+    TikTokMapperModel forMessage(String mapperName, MappingAction<MappingResult> onMapping);
+
+    TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName, MappingAction<MappingResult> onMapping);
+
+    TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName, Function<byte[], TikTokEvent> onMapping);
+
+    boolean isRegistered(String mapperName);
+
+    <T extends GeneratedMessageV3> boolean isRegistered(Class<T> mapperName);
+
+
+}

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

@@ -0,0 +1,46 @@
+package io.github.jwdeveloper.tiktok.mappers;
+
+import com.google.protobuf.GeneratedMessageV3;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokMessageMappingException;
+import io.github.jwdeveloper.tiktok.utils.ProtoBufferObject;
+
+public interface TikTokMapperHelper {
+
+    /**
+     * @param bytes        protocol buffer data bytes
+     * @param messageClass class that we want to serialize bytes to
+     * @param <T>          @messageClass must be class that is made by protocol buffer
+     * @return object of type @messageClass
+     */
+    <T extends GeneratedMessageV3> T bytesToWebcastObject(byte[] bytes, Class<T> messageClass);
+
+    /**
+     * @param bytes       protocol buffer data bytes
+     * @param messageName class that we want to serialize bytes to
+     * @return protocol buffer objects if class for @messageName has been found
+     * @throws TikTokMessageMappingException if there is no suitable class for messageName
+     */
+    Object bytesToWebcastObject(byte[] bytes, String messageName);
+
+
+    /**
+     * @param messageName checks wheaten TikTokLiveJava has class representation for certain protocol-buffer message name
+     * @return false if class is not found
+     */
+    boolean isMessageHasProtoClass(String messageName);
+
+    /**
+     * @param bytes protocol buffer data bytes
+     * @return tree structure of protocol buffer object
+     * @see ProtoBufferObject
+     */
+    ProtoBufferObject bytesToProtoBufferStructure(byte[] bytes);
+
+    /**
+     * Converts object to json
+     *
+     * @param obj any object
+     * @return pretty formatted json
+     */
+    String toJson(Object obj);
+}

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

@@ -0,0 +1,36 @@
+package io.github.jwdeveloper.tiktok.mappers;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.mappers.data.AfterMappingAction;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingAction;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+
+import java.util.List;
+import java.util.function.Function;
+
+public interface TikTokMapperModel {
+
+    /**
+     * @return name of websocket message that this mapper is mapping from
+     */
+
+    String getSourceMessageName();
+
+    /**
+     * @param action Input bytes from websocket, you can modify it and returns different bytes
+     */
+    TikTokMapperModel onBeforeMapping(MappingAction<byte[]> action);
+
+    /**
+     * @param action Input bytes from websocket. As output returns list of tiktok live events
+     */
+    TikTokMapperModel onMapping(MappingAction<MappingResult> action);
+
+
+
+    /**
+     * @param action You can modify output list of TikTokLive events
+     * @see AfterMappingAction
+     */
+    TikTokMapperModel onAfterMapping(Function<MappingResult, List<TikTokEvent>> action);
+}

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

@@ -0,0 +1,15 @@
+package io.github.jwdeveloper.tiktok.mappers.data;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface AfterMappingAction {
+    /**
+     * @param source object that was used as source to create events
+     * @param events list of events prepared before, could be modified or changed
+     * @return list of events that will be invoked
+     */
+    List<TikTokEvent> onAfterMapping(Object source, List<TikTokEvent> events);
+}

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

@@ -0,0 +1,16 @@
+package io.github.jwdeveloper.tiktok.mappers.data;
+
+import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
+
+@FunctionalInterface
+public interface MappingAction<T> {
+
+    /**
+     * @param inputBytes   incoming bytes from TikTok server. The represents protocol buffer message that was send to client
+     * @param messageName  name of protocol buffer message
+     * @param mapperHelper utils and helper methods that can be use to debbug/display/deserialize protocol buffer data
+     * @return
+     */
+    T onMapping(byte[] inputBytes, String messageName, TikTokMapperHelper mapperHelper);
+
+}

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

@@ -0,0 +1,31 @@
+package io.github.jwdeveloper.tiktok.mappers.data;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.List;
+
+@AllArgsConstructor
+@Getter
+public class MappingResult
+{
+
+    Object source;
+
+    List<TikTokEvent> events;
+
+    String message;
+
+    public static MappingResult of(Object source) {
+        return new MappingResult(source, List.of(),"");
+    }
+
+    public static MappingResult of(Object source, List<TikTokEvent> events) {
+        return new MappingResult(source, events,"");
+    }
+
+    public static MappingResult of(Object source,TikTokEvent events) {
+        return new MappingResult(source, List.of(events),"");
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/utils/JsonUtil.java

@@ -25,8 +25,10 @@ package io.github.jwdeveloper.tiktok.utils;
 import com.google.gson.ExclusionStrategy;
 import com.google.gson.FieldAttributes;
 import com.google.gson.GsonBuilder;
+import io.github.jwdeveloper.tiktok.data.dto.MessageMetaData;
 
 import java.awt.*;
+import java.time.Duration;
 import java.util.ArrayList;
 
 public class JsonUtil {
@@ -34,13 +36,25 @@ public class JsonUtil {
         return new GsonBuilder()
                 .addSerializationExclusionStrategy(new ExclusionStrategy() {
                     @Override
-                    public boolean shouldSkipField(FieldAttributes fieldAttributes) {
+                    public boolean shouldSkipField(FieldAttributes fieldAttributes)
+                    {
+
                         return false;
                     }
 
                     @Override
-                    public boolean shouldSkipClass(Class<?> aClass) {
-                        return aClass.equals(Image.class);
+                    public boolean shouldSkipClass(Class<?> aClass)
+                    {
+                        if(aClass.equals(Image.class))
+                        {
+                            return true;
+                        }
+                        if(aClass.equals(MessageMetaData.class))
+                        {
+                            return true;
+                        }
+
+                        return false;
                     }
                 })
                 .disableHtmlEscaping()

API/src/main/java/io/github/jwdeveloper/tiktok/utils/ProtoBufferFileGenerator.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.utils;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class ProtoBufferFileGenerator {
+
+
+    public static String generate(ProtoBufferObject protoBuffObj, String name) {
+
+        var sb = new StringBuilder();
+        var offset = 2;
+        sb.append("message ").append(name).append(" { \n");
+
+        var objects = new TreeMap<String, ProtoBufferObject>();
+        var objectCounter = 0;
+        for (var entry : protoBuffObj.getFields().entrySet()) {
+            var index = entry.getKey();
+            var field = entry.getValue();
+            var fieldName = field.type.toLowerCase() + "Value";
+            var value = field.value;
+            if (field.value instanceof ProtoBufferObject object) {
+                fieldName += objectCounter;
+                value = "";
+                objects.put(fieldName,object);
+                objectCounter++;
+
+            }
+            for (var i = 0; i < offset; i++) {
+                sb.append(" ");
+            }
+            sb.append(field.type).append(" ").append(fieldName)
+                    .append(" ")
+                    .append("=")
+                    .append(" ")
+                    .append(index)
+                    .append(";")
+                    .append(" //")
+                    .append(value)
+                    .append("\n");
+        }
+        sb.append(" \n");
+        for(var object : objects.entrySet())
+        {
+            var structure = generate(object.getValue(),object.getKey());
+            sb.append(structure);
+        }
+
+
+        sb.append(" \n");
+        sb.append("} \n");
+        return sb.toString();
+    }
+
+}

API/src/main/java/io/github/jwdeveloper/tiktok/utils/ProtoBufferJsonGenerator.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.utils;
+
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+
+public class ProtoBufferJsonGenerator {
+    public static JsonObject genratejson(ProtoBufferObject protoBuffObj) {
+
+        JsonObject jsonObject = new JsonObject();
+        for (var entry : protoBuffObj.getFields().entrySet()) {
+            var fieldName = entry.getKey() + "_" + entry.getValue().type;
+            if (entry.getValue().value instanceof ProtoBufferObject protoObj)
+            {
+                JsonObject childJson = genratejson(protoObj);
+                jsonObject.add(fieldName, childJson);
+                continue;
+            }
+
+            var value = entry.getValue().value.toString();
+            jsonObject.addProperty(fieldName, value);
+        }
+
+        return jsonObject;
+    }
+
+    public static String generate(ProtoBufferObject protoBufferObject) {
+        var json = genratejson(protoBufferObject);
+        var gson = new GsonBuilder().setPrettyPrinting().create();
+        return gson.toJson(json);
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/utils/ProtoBufferObject.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.utils;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public class ProtoBufferObject {
+    @Getter
+    private final Map<Integer, ProtoBufferField> fields;
+
+    public ProtoBufferObject() {
+        this.fields = new TreeMap<>();
+    }
+
+    public void addField(int index, String type, Object value) {
+        fields.put(index, new ProtoBufferField(type, value));
+    }
+
+    public void addField(int index, ProtoBufferField value) {
+        fields.put(index, value);
+    }
+
+
+    public String toProtoFile()
+    {
+        return ProtoBufferFileGenerator.generate(this,"UnknownMessage");
+    }
+
+    public String toJson()
+    {
+        return ProtoBufferJsonGenerator.generate(this);
+    }
+    @Override
+    public String toString() {
+        return toString(0, true);
+    }
+
+    public String toString(int offset ,boolean nested) {
+
+        var sb = new StringBuilder();
+        sb.append("\n");
+        for (var entry : fields.entrySet()) {
+            var index = entry.getKey();
+            var field = entry.getValue();
+
+            for(var i =0;i<offset;i++)
+            {
+                sb.append(" ");
+            }
+            sb.append(index).append(" ")
+                    .append(field.type).append(" ");
+
+            var value = field.value;
+            if (value instanceof ProtoBufferObject child) {
+                sb.append(child.toString(offset+2,nested));
+            } else {
+                sb.append(entry.getValue().value);
+            }
+
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+
+
+
+    @AllArgsConstructor
+    public class ProtoBufferField {
+        public String type;
+
+        public Object value;
+    }
+}

API/src/main/java/io/github/jwdeveloper/tiktok/utils/ProtocolUtils.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.utils;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.UnknownFieldSet;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
+
+import java.util.Base64;
+
+public class ProtocolUtils {
+    public static String toBase64(byte[] bytes) {
+
+        return Base64.getEncoder().encodeToString(bytes);
+    }
+
+    public static String toBase64(WebcastResponse.Message bytes) {
+        return Base64.getEncoder().encodeToString(bytes.toByteArray());
+    }
+
+
+    public static byte[] fromBase64(String base64) {
+
+        return Base64.getDecoder().decode(base64);
+    }
+
+    public static ProtoBufferObject getProtocolBufferStructure(byte[] bytes) {
+
+        try {
+            var files = UnknownFieldSet.parseFrom(bytes);
+            var protoBufferObject = new ProtoBufferObject();
+            createStructure(files, protoBufferObject);
+            return protoBufferObject;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void createStructure(UnknownFieldSet unknownFieldSet, ProtoBufferObject root) throws InvalidProtocolBufferException {
+        for (var entry : unknownFieldSet.asMap().entrySet()) {
+            var objectValue = entry.getValue();
+            var type = "undefind";
+            Object value = null;
+            var index = entry.getKey();
+            if (!objectValue.getLengthDelimitedList().isEmpty()) {
+                var nestedObject = new ProtoBufferObject();
+                for (var str : objectValue.getLengthDelimitedList()) {
+                    try {
+                        var nestedFieldsSet = UnknownFieldSet.parseFrom(str);
+                        createStructure(nestedFieldsSet, nestedObject);
+                    } catch (Exception e)
+                    {
+                        type = "string";
+                        value = str.toStringUtf8();
+                    }
+                }
+                if (value != null) {
+                    root.addField(index, "string", value);
+                } else {
+                    root.addField(index, "object", nestedObject);
+                }
+                continue;
+            }
+
+            if (!objectValue.getFixed32List().isEmpty()) {
+                type = "Fixed32List";
+                value = objectValue.getFixed32List();
+            }
+
+            if (!objectValue.getFixed64List().isEmpty()) {
+                type = "Fixed64List";
+                value = objectValue.getFixed64List();
+            }
+
+            if (!objectValue.getGroupList().isEmpty()) {
+                type = "getGroupList";
+                value = objectValue.getGroupList();
+            }
+
+            if (!objectValue.getVarintList().isEmpty()) {
+                type = "int";
+                value = objectValue.getVarintList().get(0);
+            }
+
+            root.addField(index, type, value);
+        }
+    }
+
+    public static WebcastResponse.Message fromBase64ToMessage(String base64) throws InvalidProtocolBufferException {
+        var bytes = fromBase64(base64);
+        return WebcastResponse.Message.parseFrom(bytes);
+    }
+
+
+}

API/src/main/proto/data.proto

@@ -64,8 +64,8 @@ message Text {
     string stringValue = 11;
     oneof textPieceType
     {
-        TextPieceUser userValue = 21;
-        TextPieceGift giftValue = 22;
+      TextPieceUser userValue = 21;
+      TextPieceGift giftValue = 22;
     }
     TextPiecePatternRef patternRefValue = 24;
   }
@@ -155,7 +155,7 @@ message BadgeStruct {
 
   message ProfileCardPanel {
     bool useNewProfileCardStyle = 1;
-  //  BadgeTextPosition badgeTextPosition = 2; // Enum
+    //  BadgeTextPosition badgeTextPosition = 2; // Enum
     ProjectionConfig projectionConfig = 3;
     ProfileContent profileContent = 4;
   }
@@ -973,4 +973,545 @@ message FanTicketRoomNoticeContent {
   int64 MatchId = 3;
   int64 EventTime = 4;
   string FanTicketIconUrl = 5;
+}
+
+message LinkerAcceptNoticeContent {
+  int64 FromUserId = 1;
+  int64 FromRoomId = 2;
+  int64 ToUserId = 3;
+}
+
+message LinkerCancelContent {
+  int64 FromUserId = 1;
+  int64 ToUserId = 2;
+  int64 CancelType = 3;
+  int64 ActionId = 4;
+}
+
+message LinkerCloseContent {
+
+}
+
+message LinkerCreateContent {
+  int64 OwnerId = 1;
+  int64 OwnerRoomId = 2;
+  int64 LinkType = 3;
+}
+
+message LinkerEnterContent {
+  repeated User LinkedUsersList = 1;
+  // LinkmicMultiLiveEnum AnchorMultiLiveEnum = 2;
+  // Data.LinkmicUserSettingInfo AnchorSettingInfo = 3;
+}
+
+message LinkerInviteContent {
+  int64 FromUserId = 1;
+  int64 FromRoomId = 2;
+  string ToRtcExtInfo = 3;
+  bool RtcJoinChannel = 4;
+  int64 Vendor = 5;
+  string SecFromUserId = 6;
+  string ToLinkmicIdStr = 7;
+  User FromUser = 8;
+  int64 RequiredMicIdx = 9;
+  map<int64, string> RtcExtInfoMap = 10;
+  //Data.LinkmicMultiLiveEnum AnchorMultiLiveEnum = 11;
+  //Data.LinkmicUserSettingInfo AnchorSettingInfo = 12;
+  string InviterLinkmicIdStr = 13;
+  //  InviteTopHostInfo FromTopHostInfo = 16;
+  int64 ActionId = 17;
+  // repeated LinkmicUserInfo LinkedUsersList = 18;
+  // Data.PerceptionDialogInfo Dialog = 19;
+  // Data.PunishEventInfo PunishInfo = 20;
+  int32 FromRoomAgeRestricted = 21;
+  // Data.Tag FromTag = 22;
+  // repeated Data.CohostABTestSetting AbTestSettingList = 23;
+  // Data.LinkerInviteMessageExtra LinkerInviteMsgExtra = 101;
+}
+
+message LinkerKickOutContent {
+  int64 FromUserId = 1;
+  //LinkMic.KickoutReason KickoutReason = 2;
+}
+
+message LinkerLeaveContent {
+  int64 UserId = 1;
+  string LinkmicIdStr = 2;
+  int64 SendLeaveUid = 3;
+  int64 LeaveReason = 4;
+}
+
+message LinkerLinkedListChangeContent {
+  repeated User LinkedUsersList = 1;
+}
+
+message LinkerListChangeContent {
+  repeated LinkLayerListUser LinkedUsersList = 1;
+  repeated LinkLayerListUser AppliedUsersList = 2;
+  repeated LinkLayerListUser ConnectingUsersList = 3;
+}
+
+message LinkerMediaChangeContent {
+  // MicIdxOperation Op = 1;
+  int64 ToUserId = 2;
+  int64 AnchorId = 3;
+  int64 RoomId = 4;
+  // LinkerSceneType ChangeScene = 5;
+}
+
+message LinkerMicIdxUpdateContent {
+  LinkerMicIdxUpdateInfo MicIdxUpdateInfo = 1;
+}
+
+message LinkerMicIdxUpdateInfo {
+  // MicIdxOperation Op = 1;
+  int64 UserId = 2;
+  int64 MicIdx = 3;
+}
+
+message LinkerMuteContent {
+  int64 UserId = 1;
+  // Data.MuteStatus Status = 2;
+}
+
+message LinkerRandomMatchContent {
+  User User = 1;
+  int64 RoomId = 2;
+  int64 InviteType = 3;
+  string MatchId = 4;
+  int64 InnerChannelId = 5;
+}
+
+message LinkerReplyContent {
+  int64 FromUserId = 1;
+  int64 FromRoomId = 2;
+  // LinkmicInfo FromUserLinkmicInfo = 3;
+  int64 ToUserId = 4;
+  //  LinkmicInfo ToUserLinkmicInfo = 5;
+  int64 LinkType = 6;
+  int64 ReplyStatus = 7;
+  LinkerSetting LinkerSetting = 8;
+  User FromUser = 9;
+  User ToUser = 10;
+  map<int64, string> RtcExtInfoMap = 11;
+  LinkerMicIdxUpdateInfo InviteeMicIdxUpdateInfo = 12;
+  map<int64, int64> ApplierMicIdxInfoMap = 13;
+  //  Data.LinkmicMultiLiveEnum AnchorMultiLiveEnum = 14;
+  //  Data.LinkmicUserSettingInfo AnchorSettingInfo = 15;
+  int64 ActionId = 16;
+  // repeated LinkmicUserInfo LinkedUsersList = 17;
+  int64 SourceType = 18;
+}
+
+message LinkerSetting {
+  int64 MaxMemberLimit = 1;
+  int64 LinkType = 2;
+  int64 Scene = 3;
+  int64 OwnerUserId = 4;
+  int64 OwnerRoomId = 5;
+  int64 Vendor = 6;
+}
+
+message LinkerSysKickOutContent {
+  int64 UserId = 1;
+  string LinkmicIdStr = 2;
+}
+
+message LinkerUpdateUserContent {
+  int64 FromUserId = 1;
+  int64 ToUserId = 2;
+  map<string, string> UpdateInfoMap = 3;
+}
+
+message LinkerUpdateUserSettingContent {
+  // Data.LinkmicUserSettingInfo UpdateUserSettingInfo = 1;
+}
+
+message LinkerWaitingListChangeContent {
+
+}
+
+
+message LinkmicUserSettingInfo {
+  int64 userId = 1;
+  int64 layout = 2; // @warning Enum not found, should be Layout
+  int64 fixMicNum = 3; // @warning Enum not found, should be FixMicNum
+  int64 allowRequestFromUser = 4; // @warning Enum not found, should be AllowRequestFromUser
+  int64 allowRequestFromFollowerOnly = 5; // @warning Enum not found, should be AllowRequestFromFollowerOnly
+  LinkmicApplierSortSetting applierSortSetting = 7; // Enum
+}
+
+
+message Player {
+  int64 roomId = 1;
+  int64 userId = 2;
+}
+
+message AllListUser {
+  repeated LinkLayerListUser linkedList = 2;
+  repeated LinkLayerListUser appliedList = 3;
+  repeated LinkLayerListUser invitedList = 4;
+  repeated LinkLayerListUser readyList = 5;
+}
+
+message LinkLayerListUser {
+  User user = 1;
+  int64 linkmicId = 2;
+  Position pos = 3;
+  int64 linkedTimeNano = 4;
+  string appVersion = 5;
+  int64 magicNumber1 = 7;
+}
+
+message Position {
+  int32 type = 1;
+  LinkPosition link = 2;
+}
+
+message LinkPosition {
+  int32 position = 1;
+  int32 opt = 2;
+}
+
+message GroupPlayer {
+  int64 channelId = 1;
+  User user = 2;
+}
+
+message DSLConfig {
+  int32 sceneVersion = 1;
+  string layoutId = 2;
+}
+
+message GroupChannelAllUser {
+  int64 groupChannelId = 1;
+  repeated GroupChannelUser userList = 2;
+}
+
+message GroupChannelUser {
+  int64 channelId = 1;
+  GroupStatus status = 2; // Enum
+  TextType type = 3; // Enum
+  AllListUser allUser = 4;
+  int64 joinTime = 5;
+  int64 linkedTime = 6;
+  GroupPlayer ownerUser = 7;
+}
+
+message RTCExtraInfo {
+  RTCEngineConfig liveRtcEngineConfig = 1;
+  repeated RTCLiveVideoParam liveRtcVideoParamList = 2;
+  RTCBitrateMap rtcBitrateMap = 3;
+  int32 rtcFps = 4;
+  string rtcBusinessId = 8;
+  int32 interactClientType = 10;
+
+  message RTCEngineConfig {
+    string rtcAppId = 1;
+    string rtcUserId = 2;
+    string rtcToken = 3;
+    int64 rtcChannelId = 4;
+  }
+
+  message RTCLiveVideoParam {
+    int32 strategyId = 1;
+    RTCVideoParam params = 2;
+  }
+
+  message RTCVideoParam {
+    int32 width = 1;
+    int32 height = 2;
+    int32 fps = 3;
+    int32 bitrateKbps = 4;
+  }
+
+  message RTCBitrateMap {
+    int32 xx1 = 1;
+    int32 xx2 = 2;
+    int32 xx3 = 3;
+    int32 xx4 = 4;
+  }
+}
+
+message CreateChannelContent {
+  Player  owner = 1;
+  string ownerLinkMicId = 2;
+}
+
+message ListChangeContent {
+  TextType type = 1; // Enum
+  AllListUser list = 2;
+}
+
+message MultiLiveContent {
+  InviteBizContent inviteBizContent = 2;
+  ReplyBizContent replyBizContent = 3;
+  PermitBizContent permitBizContent = 4;
+  KickOutBizContent kickOutBizContent = 6;
+
+
+  message InviteBizContent {
+    LinkmicUserSettingInfo anchorSettingInfo = 1;
+    int64 inviteSource = 2; // @warning Enum not found, should be InviteSource
+    User operatorUserInfo = 3;
+    int64 operatorLinkAdminType = 4; // @warning Enum not found, should be OperatorLinkAdminType
+    User inviteeUserInfo = 5;
+  }
+
+
+  message ReplyBizContent {
+    int32 linkType = 1;
+    int32 isTurnOffInvitation = 2;
+    User replyUserInfo = 3;
+  }
+
+  message PermitBizContent {
+    LinkmicUserSettingInfo anchorSettingInfo = 1;
+    int64 expireTimestamp = 2;
+    User operatorUserInfo = 3;
+    int64 operatorLinkAdminType = 4; // @warning Enum not found, should be OperatorLinkAdminType
+  }
+
+  message KickOutBizContent {
+    User operatorUserInfo = 1;
+    int64 operatorLinkAdminType = 2; // @warning Enum not found, should be OperatorLinkAdminType
+    User kickPlayerUserInfo = 3;
+  }
+
+}
+
+
+message InviteContent {
+  Player  invitor = 1;
+  RTCExtraInfo inviteeRtcExtInfo = 2;
+  string invitorLinkMicId = 3;
+  string inviteeLinkMicId = 4;
+  bool isOwner = 5;
+  Position pos = 6;
+  DSLConfig dsl = 7;
+  User invitee = 8;
+  User operator = 9;
+}
+
+
+// @ApplyContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message ApplyContent {
+  Player  applier = 1;
+  string applierLinkMicId = 2;
+}
+
+
+// @PermitApplyContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message PermitApplyContent {
+  Player  permiter = 1;
+  string permiterLinkMicId = 2;
+  Position applierPos = 3;
+  ReplyStatus replyStatus = 4; // Enum
+  DSLConfig dsl = 5;
+  User applier = 6;
+  User operator = 7;
+  string applierLinkMicId = 8;
+}
+
+
+// @ReplyInviteContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message ReplyInviteContent {
+  Player  invitee = 1;
+  ReplyStatus replyStatus = 2; // Enum
+  string inviteeLinkMicId = 3;
+  Position inviteePos = 4;
+  Player  inviteOperatorUser = 5;
+}
+
+
+// @KickOutContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message KickOutContent {
+  Player  offliner = 1;
+  KickoutReason kickoutReason = 2; // Enum
+}
+
+
+// @CancelApplyContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message CancelApplyContent {
+  Player  applier = 1;
+  string applierLinkMicId = 2;
+}
+
+
+// @CancelInviteContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message CancelInviteContent {
+  Player  invitor = 1;
+  string invitorLinkMicId = 2;
+  string inviteeLinkMicId = 3;
+  int64 inviteSeqId = 4;
+  Player  invitee = 5;
+}
+
+
+// @LeaveContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message LeaveContent {
+  Player  leaver = 1;
+  int64 leaveReason = 2;
+}
+
+
+// @FinishChannelContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message FinishChannelContent {
+  Player  owner = 1;
+  int64 finishReason = 2;
+}
+
+
+// @JoinDirectContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message JoinDirectContent {
+  LinkLayerListUser joiner = 1;
+  AllListUser allUsers = 2;
+}
+
+
+// @LeaveJoinGroupContent
+// proto.webcast.im
+// C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+message LeaveJoinGroupContent {
+  GroupPlayer operator = 1;
+  int64 groupChannelId = 2;
+  string leaveSource = 3;
+}
+
+
+// @PermitJoinGroupContent
+// proto.webcast.im
+message PermitJoinGroupContent {
+  GroupPlayer approver = 1;
+  AgreeStatus agreeStatus = 2; // Enum
+  TextType type = 3; // Enum
+  repeated RTCExtraInfo groupExtInfoList = 4;
+  GroupChannelAllUser groupUser = 5;
+}
+
+
+// @CancelJoinGroupContent
+// proto.webcast.im
+message CancelJoinGroupContent {
+  repeated GroupPlayer leaverList = 1;
+  GroupPlayer operator = 2;
+  TextType type = 3; // Enum
+}
+
+
+
+message P2PGroupChangeContent {
+  repeated RTCExtraInfo groupExtInfoList = 1;
+  GroupChannelAllUser groupUser = 2;
+}
+
+
+message BusinessContent {
+  int64 overLength = 1;
+  MultiLiveContent multiLiveContent = 100;
+  CohostContent cohostContent = 200;
+
+  message CohostContent {
+    JoinGroupBizContent joinGroupBizContent = 1;
+
+  }
+
+  message JoinGroupBizContent {
+    int32 fromRoomAgeRestricted = 1;
+    Tag fromTag = 2;
+    PerceptionDialogInfo dialog = 3;
+    PunishEventInfo punishInfo = 4;
+    JoinGroupMessageExtra joinGroupMsgExtra = 101;
+  }
+
+  message Tag {
+    int32 tagType = 1;
+    string tagValue = 2;
+    string tagText = 3;
+  }
+
+  message PerceptionDialogInfo {
+    int64 iconType = 1; // @warning Enum not found, should be IconType
+    Text title = 2;
+    Text subTitle = 3;
+    Text adviceActionText = 4;
+    Text defaultActionText = 5;
+    string violationDetailUrl = 6;
+    int32 scene = 7;
+    int64 targetUserId = 8;
+    int64 targetRoomId = 9;
+    int64 countDownTime = 10;
+    bool showFeedback = 11;
+    repeated PerceptionFeedbackOption feedbackOptionsList = 12;
+    int64 policyTip = 13;
+  }
+
+  message PerceptionFeedbackOption {
+    int64 id = 1;
+    string contentKey = 2;
+  }
+
+  message JoinGroupMessageExtra {
+    int64 sourceType = 1;
+    RivalExtra extra = 2;
+    repeated RivalExtra otherUsersList = 3;
+
+
+    // @RivalExtra
+    // proto.webcast.im.JoinGroupMessageExtra
+    // C:\Users\ja\RiderProjects\TikTokProBufferGenerator\Application\output\sources\test.js
+    message RivalExtra {
+      int64 userCount = 4;
+      Image avatarThumb = 5;
+      string displayId = 6;
+      AuthenticationInfo authenticationInfo = 7;
+      string nickname = 8;
+      int64 followStatus = 9;
+      Hashtag hashtag = 10;
+      TopHostInfo topHostInfo = 11;
+      int64 userId = 12;
+      bool isBestTeammate = 13;
+
+      message AuthenticationInfo {
+        string customVerify = 1;
+        string enterpriseVerifyReason = 2;
+        Image authenticationBadge = 3;
+      }
+    }
+  }
+  message Hashtag {
+    int64 id = 1;
+    string title = 2;
+    Image image = 3;
+    HashtagNamespace namespace = 4; // Enum
+  }
+
+  message TopHostInfo {
+    string rankType = 1;
+    int64 topIndex = 2;
+  }
+}
+
+message JoinGroupContent {
+  GroupChannelAllUser groupUser = 1;
+  GroupPlayer joinUser = 2;
+  TextType type = 3; // Enum
 }

API/src/main/proto/enums.proto

@@ -25,6 +25,85 @@ enum EmotePrivateType {
   EMOTE_PRIVATE_TYPE_SUB_WAVE = 1;
 }
 
+enum TextType {
+  DISPLAY_TEXT = 0;
+  CONTENT = 1;
+}
+
+enum LinkmicApplierSortSetting {
+  LINKMIC_APPLIER_SORT_SETTING_NONE = 0;
+  LINKMIC_APPLIER_SORT_SETTING_BY_GIFT_SCORE = 1;
+}
+
+enum HashtagNamespace {
+  GLOBAL = 0;
+  GAMING = 1;
+}
+
+enum AgreeStatus {
+  AGREE_UNKNOWN = 0;
+  AGREE = 1;
+  REJECT = 2;
+}
+
+enum KickoutReason {
+  KICKOUT_REASON_UNKNOWN = 0;
+  KICKOUT_REASON_FIRST_FRAME_TIMEOUT = 1;
+  KICKOUT_REASON_BY_HOST = 2;
+  KICKOUT_REASON_RTC_LOST_CONNECTION = 3;
+  KICKOUT_REASON_BY_PUNISH = 4;
+  KICKOUT_REASON_BY_ADMIN = 5;
+  KICKOUT_REASON_HOST_REMOVE_ALL_GUESTS = 6;
+}
+
+
+enum GroupStatus {
+  GROUP_STATUS_UNKNOWN = 0;
+  GROUP_STATUS_WAITING = 1;
+  GROUP_STATUS_LINKED = 3;
+}
+
+enum BusinessCase {
+  BUSINESS_NOT_SET = 0;
+  APPLY_BIZ_CONTENT = 1;
+  INVITE_BIZ_CONTENT = 2;
+  REPLY_BIZ_CONTENT = 3;
+  PERMIT_BIZ_CONTENT = 4;
+  JOIN_DIRECT_BIZ_CONTENT = 5;
+  KICK_OUT_BIZ_CONTENT = 6;
+  LIST_CHANGE_BIZ_CONTENT = 11;
+  MULTI_LIVE_CONTENT = 100;
+  COHOST_CONTENT = 200;
+}
+
+enum ReplyStatus {
+  REPLY_STATUS_UNKNOWN = 0;
+  REPLY_STATUS_AGREE = 1;
+  REPLY_STATUS_REFUSE_PERSONALLY = 2;
+  REPLY_STATUS_REFUSE_TYPE_NOT_SUPPORT = 3;
+  REPLY_STATUS_REFUSE_PROCESSING_INVITATION = 4;
+  REPLY_STATUS_REFUSE_BY_TIMEOUT = 5;
+  REPLY_STATUS_REFUSE_EXCEPTION = 6;
+  REPLY_STATUS_REFUSE_SYSTEM_NOT_SUPPORTED = 7;
+  REPLY_STATUS_REFUSE_SUBTYPE_DIFFERENCE = 8;
+  REPLY_STATUS_REFUSE_IN_MICROOM = 9;
+  REPLY_STATUS_REFUSE_NOT_LOAD_PLUGIN = 10;
+  REPLY_STATUS_REFUSE_IN_MULTI_GUEST = 11;
+  REPLY_STATUS_REFUSE_PAUSE_LIVE = 12;
+  REPLY_STATUS_REFUSE_OPEN_CAMERA_DIALOG_SHOWING = 13;
+  REPLY_STATUS_REFUSE_DRAW_GUESSING = 14;
+  REPLY_STATUS_REFUSE_RANDOM_MATCHING = 15;
+  REPLY_STATUS_REFUSE_IN_MATCH_PROCESSING = 16;
+  REPLY_STATUS_REFUSE_IN_MICROOM_FOR_MULTI_COHOST = 17;
+  REPLY_STATUS_REFUSE_COHOST_FINISHED = 18;
+  REPLY_STATUS_REFUSE_NOT_CONNECTED = 19;
+  REPLY_STATUS_REFUSE_LINKMIC_FULL = 20;
+  REPLY_STATUS_REFUSE_ARC_INCOMPATIBLE = 21;
+  REPLY_STATUS_REFUSE_PROCESSING_OTHER_INVITE = 22;
+  REPLY_STATUS_REFUSE_PROCESSING_OTHER_APPLY = 23;
+  REPLY_STATUS_REFUSE_IN_ANCHOR_COHOST = 24;
+  REPLY_STATUS_REFUSE_TOPIC_PAIRING = 25;
+}
 
 enum SubscribeType {
   SUBSCRIBETYPE_ONCE = 0;
@@ -68,6 +147,7 @@ enum MemberMessageAction {
 enum ControlAction {
   ControlActionUNKNOWN = 0;
   STREAM_PAUSED = 1; // Stream Paused by Host
+  STREAM_UNPAUSED = 2;
   STREAM_ENDED = 3; // Stream Ended by Host
 }
 
@@ -110,4 +190,76 @@ enum BarrageType
   FansLevelUpgrade = 10;
   FansLevelEntrance = 11;
   GamePartnership = 12;
+}
+
+enum EnvelopeBusinessType
+{
+  BusinessTypeUnknown = 0;
+  BusinessTypeUserDiamond = 1;
+  BusinessTypePlatformDiamond = 2;
+  BusinessTypePlatformShell = 3;
+  BusinessTypePortal = 4;
+  BusinessTypePlatformMerch = 5;
+  BusinessTypeEoYDiamond = 6;
+  BusinessTypeFanClubGtM = 7;
+}
+enum EnvelopeFollowShowStatus
+{
+  EnvelopeFollowShowUnknown = 0;
+  EnvelopeFollowShow = 1;
+  EnvelopeFollowNotShow = 2;
+}
+
+enum EnvelopeDisplay
+{
+  EnvelopeDisplayUnknown = 0;
+  EnvelopeDisplayNew = 1;
+  EnvelopeDisplayHide = 2;
+}
+
+
+enum CommonContentCase {
+  COMMON_CONTENT_NOT_SET = 0;
+  CREATE_CHANNEL_CONTENT = 100;
+  LIST_CHANGE_CONTENT = 102;
+  INVITE_CONTENT = 103;
+  APPLY_CONTENT = 104;
+  PERMIT_APPLY_CONTENT = 105;
+  REPLY_INVITE_CONTENT = 106;
+  KICK_OUT_CONTENT = 107;
+  CANCEL_APPLY_CONTENT = 108;
+  CANCEL_INVITE_CONTENT = 109;
+  LEAVE_CONTENT = 110;
+  FINISH_CONTENT = 111;
+  JOIN_DIRECT_CONTENT = 112;
+  JOIN_GROUP_CONTENT = 113;
+  PERMIT_GROUP_CONTENT = 114;
+  CANCEL_GROUP_CONTENT = 115;
+  LEAVE_GROUP_CONTENT = 116;
+  P2P_GROUP_CHANGE_CONTENT = 117;
+  GROUP_CHANGE_CONTENT = 118;
+}
+
+
+
+enum MessageType {
+  MESSAGETYPE_SUBSUCCESS = 0;
+  MESSAGETYPE_ANCHORREMINDER = 1;
+  MESSAGETYPE_ENTERROOMEXPIRESOON = 2;
+  MESSAGETYPE_SUBGOALCREATETOANCHOR = 3;
+  MESSAGETYPE_SUBGOALCOMPLETETOAUDIENCE = 4;
+  MESSAGETYPE_SUBGOALCOMPLETETOANCHOR = 5;
+  MESSAGETYPE_SUBGIFTTIKTOK2USERNOTICE = 6;
+  MESSAGETYPE_SUBGIFTTIKTOK2ANCHORNOTICE = 7;
+  MESSAGETYPE_SUBGIFTTRECEIVESENDNOTICE = 8;
+  MESSAGETYPE_SUBGIFTSENDSUCCEEDROOMMESSAGE = 9;
+  MESSAGETYPE_SUBGIFTSENDSUCCEEDANCHORNOTICE = 10;
+  MESSAGETYPE_SUBGIFTLOWVERSIONUPGRADENOTICE = 11;
+  MESSAGETYPE_SUBGIFTUSERBUYAUTHNOTICE = 12;
+}
+
+enum Scene {
+  SCENE_UNKNOWN = 0;
+  SCENE_CO_HOST = 2;
+  SCENE_MULTI_LIVE = 4;
 }

API/src/main/proto/webcast.proto

@@ -68,7 +68,6 @@ message WebcastGiftMessage {
   int32 repeatCount = 5;
   int32 comboCount = 6;
   User user = 7;
-  User toUser = 8;
   int32 repeatEnd = 9;
   int64 groupId = 11;
   int64 incomeTaskgifts = 12;
@@ -81,6 +80,13 @@ message WebcastGiftMessage {
   bool isFirstSent = 25;
   string orderId = 28;
   UserIdentity userIdentity = 32;
+  UserGiftReciever userGiftReciever = 23;
+
+  message UserGiftReciever
+  {
+      int64 userId =1;
+      string deviceName = 10;
+  }
 
   message GiftIMPriority {
     repeated int64 queueSizesList = 1;
@@ -177,6 +183,8 @@ message WebcastCaptionMessage {
   }
 }
 
+
+
 // Comment sent by User
 //@WebcastChatMessage
 message WebcastChatMessage {
@@ -246,13 +254,13 @@ message WebcastEmoteChatMessage {
 message WebcastEnvelopeMessage {
   Common common = 1;
   EnvelopeInfo envelopeInfo = 2;
-  int64 display = 3; // @warning Enum not found, should be Display
+  EnvelopeDisplay display = 3; // @warning Enum not found, should be Display
 
   // @EnvelopeInfo
   // proto.webcast.im.EnvelopeMessage
   message EnvelopeInfo {
     string envelopeId = 1;
-    int64 businessType = 2; // @warning Enum not found, should be BusinessType
+    EnvelopeBusinessType businessType = 2;
     string envelopeIdc = 3;
     string sendUserName = 4;
     int32 diamondCount = 5;
@@ -262,7 +270,7 @@ message WebcastEnvelopeMessage {
     Image sendUserAvatar = 9;
     string createAt = 10;
     string roomId = 11;
-    int64 followShowStatus = 12; // @warning Enum not found, should be FollowShowStatus
+    EnvelopeFollowShowStatus followShowStatus = 12; // @warning Enum not found, should be FollowShowStatus
     int32 skinId = 13;
   }
 }
@@ -440,7 +448,7 @@ message WebcastMemberMessage {
 //@WebcastPollMessage
 message WebcastPollMessage {
   Common common = 1;
-  int32 messageType = 2;
+  MessageType messageType = 2;
   int64 pollId = 3;
   PollStartContent startContent = 4;
   PollEndContent endContent = 5;
@@ -505,6 +513,9 @@ message WebcastHourlyRankMessage {
   }
 }
 
+
+//<Battles>
+
 //@WebcastLinkMicArmies
 message WebcastLinkMicArmies {
   Common common = 1;
@@ -521,6 +532,45 @@ message WebcastLinkMicArmies {
   uint32 data4 = 12;
   uint32 data5 = 13;
 }
+//@WebcastLinkMicBattlePunishFinish
+message WebcastLinkMicBattlePunishFinish {
+  Common Header = 1;
+  uint64 Id1 = 2;
+  uint64 Timestamp = 3;
+  uint32 Data4 = 4;
+  uint64 Id2 = 5;
+  LinkMicBattlePunishFinishData Data6 = 6;
+
+  message LinkMicBattlePunishFinishData {
+    uint64 Id2 = 1; // Same as Id2 in outer object (loser?)
+    uint64 Timestamp = 2;
+    uint32 Data3 = 3;
+    uint64 Id1 = 4; // Same as Id1 in outer object (winner?)
+    uint32 Data5 = 5;
+    uint32 Data6 = 6;
+    uint32 Data8 = 8;
+  }
+}
+
+//@WebcastLinkmicBattleTaskMessage
+message WebcastLinkmicBattleTaskMessage {
+  Common Header = 1;
+  uint32 Data2 = 2;
+  LinkmicBattleTaskData Data3 = 3;
+  LinkmicBattleTaskData2 Data5 = 5;
+
+  message LinkmicBattleTaskData {
+    BattleTaskData Data1 = 1;
+  }
+  message BattleTaskData {
+    uint32 Data1 = 1;
+  }
+
+  message LinkmicBattleTaskData2 {
+    uint32 Data1 = 1;
+    uint32 Data2 = 2;
+  }
+}
 
 //@WebcastLinkMicBattle
 message WebcastLinkMicBattle {
@@ -570,11 +620,10 @@ message WebcastLinkMicFanTicketMethod {
   Common common = 1;
   FanTicketRoomNoticeContent FanTicketRoomNotice = 2;
 }
-
 //@WebcastLinkMicMethod
 message WebcastLinkMicMethod {
   Common common = 1;
-  int64 messageType = 2;
+  MessageType messageType = 2;
   string accessKey = 3;
   int64 anchorLinkmicId = 4;
   int64 userId = 5;
@@ -588,6 +637,8 @@ message WebcastLinkMicMethod {
   int64 inviteUid = 13;
 }
 
+//<Battles>
+
 //@WebcastLiveIntroMessage
 message WebcastLiveIntroMessage {
   Common common = 1;
@@ -681,39 +732,63 @@ message WebcastSystemMessage {
 //@WebcastLinkMessage
 message WebcastLinkMessage {
   Common common = 1;
-  uint32 data1 = 2;
-  uint64 data2 = 3;
-  uint32 data3 = 4;
-  LinkMessageData data = 18;
-  LinkMessageUserContainer user = 20;
-  string token = 200;
-
-  message LinkMessageData {
-    DataContainer data = 1; // index 1 is an Id
-  }
-
-  message LinkMessageUserContainer {
-    LinkMessageUser user = 1;
-    repeated LinkMessageUser otherUsers = 2;
-
-    message LinkMessageUser {
-      User user = 1;
-      uint64 timeStamp = 2;
-      uint32 data1 = 4;
-      string idString = 5;
-      uint32 data2 = 7;
-    }
-  }
+  MessageType MessageType = 2;
+  int64 LinkerId = 3;
+  Scene Scene = 4;
+  LinkerInviteContent InviteContent = 5;
+  LinkerReplyContent ReplyContent = 6;
+  LinkerCreateContent CreateContent = 7;
+  LinkerCloseContent CloseContent = 8;
+  LinkerEnterContent EnterContent = 9;
+  LinkerLeaveContent LeaveContent = 10;
+  LinkerCancelContent CancelContent = 11;
+  LinkerKickOutContent KickOutContent = 12;
+  LinkerLinkedListChangeContent LinkedListChangeContent = 13;
+  LinkerUpdateUserContent UpdateUserContent = 14;
+  LinkerWaitingListChangeContent WaitingListChangeContent = 15;
+  LinkerMuteContent MuteContent = 16;
+  LinkerRandomMatchContent RandomMatchContent = 17;
+  LinkerUpdateUserSettingContent UpdateUserSettingContent = 18;
+  LinkerMicIdxUpdateContent MicIdxUpdateContent = 19;
+  LinkerListChangeContent ListChangeContent = 20;
+ // CohostListChangeContent CohostListChangeContent = 21;
+  LinkerMediaChangeContent MediaChangeContent = 22;
+  LinkerAcceptNoticeContent ReplyAcceptNoticeContent = 23;
+  LinkerSysKickOutContent SysKickOutContent = 101;
+ // LinkmicUserToastContent UserToastContent = 102;
+  string Extra = 200;
+  int64 ExpireTimestamp = 201;
+  string TransferExtra = 202;
 }
 
-//@WebcastLinkLayerMessage
+
+// @WebcastLinkLayerMessage
 message WebcastLinkLayerMessage {
   Common common = 1;
-  LinkLayerMessageType messageType = 2;
+  MessageType messageType = 2; // Enum
   int64 channelId = 3;
+  Scene scene = 4; // Enum
+  CreateChannelContent createChannelContent = 100;
+  ListChangeContent listChangeContent = 102;
+  InviteContent inviteContent = 103;
+  ApplyContent applyContent = 104;
+  PermitApplyContent permitApplyContent = 105;
+  ReplyInviteContent replyInviteContent = 106;
+  KickOutContent kickOutContent = 107;
+  CancelApplyContent cancelApplyContent = 108;
+  CancelInviteContent cancelInviteContent = 109;
+  LeaveContent leaveContent = 110;
+  FinishChannelContent finishContent = 111;
+  JoinDirectContent joinDirectContent = 112;
+  JoinGroupContent joinGroupContent = 113;
+  PermitJoinGroupContent permitGroupContent = 114;
+  CancelJoinGroupContent cancelGroupContent = 115;
+  LeaveJoinGroupContent leaveGroupContent = 116;
+  P2PGroupChangeContent p2pGroupChangeContent = 117;
+  BusinessContent businessContent = 200;
 }
 
-
+// @RoomVerifyMessage
 message RoomVerifyMessage {
   Common common = 1;
   int32 action = 2;

Client/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>0.0.25-Release</version>
+        <version>1.0.9-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -41,12 +41,28 @@
             <artifactId>Java-WebSocket</artifactId>
             <version>1.5.4</version>
         </dependency>
-
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>7.4.0</version> <!-- Use the desired TestNG version -->
+            <scope>test</scope>
+        </dependency>
 
     </dependencies>
 
     <build>
         <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.0.0-M5</version>
+                <configuration>
+                    <argLine>-Xmx512m</argLine>
+                    <suiteXmlFiles>
+                        <suiteXmlFile>testng.xml</suiteXmlFile>
+                    </suiteXmlFiles>
+                </configuration>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>

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

@@ -23,12 +23,69 @@
 package io.github.jwdeveloper.tiktok;
 
 
+import io.github.jwdeveloper.tiktok.http.TikTokDataChecker;
 import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 
+import java.util.concurrent.CompletableFuture;
+
 public class TikTokLive
 {
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return LiveClientBuilder
+     */
     public static LiveClientBuilder newClient(String hostName)
     {
         return new TikTokLiveClientBuilder(hostName);
     }
+
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true if live is Online, false if is offline
+     */
+    public static boolean isLiveOnline(String hostName)
+    {
+       return new TikTokDataChecker().isOnline(hostName);
+    }
+
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true if live is Online, false if is offline
+     */
+    public static CompletableFuture<Boolean> isLiveOnlineAsync(String hostName)
+    {
+        return new TikTokDataChecker().isOnlineAsync(hostName);
+    }
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true is hostName name is valid and exists, false if not
+     */
+    public static boolean isHostNameValid(String hostName)
+    {
+        return new TikTokDataChecker().isHostNameValid(hostName);
+    }
+
+    /**
+     *
+     * @param hostName profile name of Tiktok user could be found in profile link
+     *    example: https://www.tiktok.com/@dostawcavideo  hostName would be dostawcavideo
+     * @return true is hostName name is valid and exists, false if not
+     */
+    public static CompletableFuture<Boolean> isHostNameValidAsync(String hostName)
+    {
+        return new TikTokDataChecker().isHostNameValidAsync(hostName);
+    }
+
 }

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

@@ -25,6 +25,8 @@ package io.github.jwdeveloper.tiktok;
 import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokReconnectingEvent;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveOfflineHostException;
 import io.github.jwdeveloper.tiktok.gifts.TikTokGiftManager;
@@ -92,8 +94,7 @@ public class TikTokLiveClient implements LiveClient {
     public void connect() {
         try {
             tryConnect();
-        } catch (TikTokLiveException e)
-        {
+        } catch (TikTokLiveException e) {
             setState(ConnectionState.DISCONNECTED);
             tikTokEventHandler.publish(this, new TikTokErrorEvent(e));
             tikTokEventHandler.publish(this, new TikTokDisconnectedEvent());
@@ -108,11 +109,15 @@ public class TikTokLiveClient implements LiveClient {
                 this.connect();
             }
             throw e;
+        } catch (Exception e) {
+            logger.info("Unhandled exception report this bug to github https://github.com/jwdeveloper/TikTokLiveJava/issues");
+            this.disconnect();
+            e.printStackTrace();
         }
     }
 
     public void disconnect() {
-        if (!liveRoomInfo.hasConnectionState(ConnectionState.CONNECTED)) {
+        if (liveRoomInfo.hasConnectionState(ConnectionState.DISCONNECTED)) {
             return;
         }
         webSocketClient.stop();
@@ -127,6 +132,7 @@ public class TikTokLiveClient implements LiveClient {
 
         setState(ConnectionState.CONNECTING);
 
+
         apiService.updateSessionId();
 
         if (clientSettings.getRoomId() != null) {
@@ -138,14 +144,24 @@ public class TikTokLiveClient implements LiveClient {
         }
 
 
-        var roomData = apiService.fetchRoomInfo();
-        if (roomData.getStatus() != LiveRoomMeta.LiveRoomStatus.HostOnline)  {
-            throw new TikTokLiveOfflineHostException("LiveStream for Host name could not be found. Is the Host online?");
+        var liveRoomMeta = apiService.fetchRoomInfo();
+        if (liveRoomMeta.getStatus() == LiveRoomMeta.LiveRoomStatus.HostNotFound) {
+            throw new TikTokLiveOfflineHostException("LiveStream for Host name could not be found.");
         }
+        if (liveRoomMeta.getStatus() == LiveRoomMeta.LiveRoomStatus.HostOffline) {
+            throw new TikTokLiveOfflineHostException("LiveStream for not be found, is the Host offline?");
+        }
+
+        liveRoomInfo.setTitle(liveRoomMeta.getTitie());
+        liveRoomInfo.setViewersCount(liveRoomMeta.getViewers());
+        liveRoomInfo.setTotalViewersCount(liveRoomMeta.getTotalViewers());
+        liveRoomInfo.setAgeRestricted(liveRoomMeta.isAgeRestricted());
+        liveRoomInfo.setHost(liveRoomMeta.getHost());
 
         var clientData = apiService.fetchClientData();
         webSocketClient.start(clientData, this);
         setState(ConnectionState.CONNECTED);
+        tikTokEventHandler.publish(this, new TikTokRoomInfoEvent(liveRoomInfo));
     }
 
 
@@ -174,4 +190,8 @@ public class TikTokLiveClient implements LiveClient {
         liveRoomInfo.setConnectionState(connectionState);
     }
 
+    public void publishEvent(TikTokEvent event)
+    {
+        tikTokEventHandler.publish(this, event);
+    }
 }

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

@@ -24,12 +24,13 @@ package io.github.jwdeveloper.tiktok;
 
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.envelop.TikTokChestEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
+import io.github.jwdeveloper.tiktok.data.events.http.TikTokHttpResponseEvent;
 import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
 import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomPinEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomUserInfoEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokFollowEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
@@ -40,18 +41,27 @@ import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandl
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.gifts.TikTokGiftManager;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
-import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
-import io.github.jwdeveloper.tiktok.handlers.events.TikTokGiftEventHandler;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandler;
 import io.github.jwdeveloper.tiktok.http.TikTokApiService;
 import io.github.jwdeveloper.tiktok.http.TikTokCookieJar;
 import io.github.jwdeveloper.tiktok.http.TikTokHttpClient;
 import io.github.jwdeveloper.tiktok.http.TikTokHttpRequestFactory;
 import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
 import io.github.jwdeveloper.tiktok.listener.TikTokListenersManager;
+import io.github.jwdeveloper.tiktok.live.GiftManager;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 import io.github.jwdeveloper.tiktok.mappers.TikTokGenericEventMapper;
+import io.github.jwdeveloper.tiktok.mappers.TikTokLiveMapper;
+import io.github.jwdeveloper.tiktok.mappers.TikTokLiveMapperHelper;
+import io.github.jwdeveloper.tiktok.mappers.TikTokMapper;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokCommonEventHandler;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokGiftEventHandler;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokRoomInfoEventHandler;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokSocialMediaEventHandler;
+import io.github.jwdeveloper.tiktok.messages.webcast.*;
 import io.github.jwdeveloper.tiktok.utils.ConsoleColors;
 import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;
 
@@ -65,9 +75,11 @@ import java.util.logging.*;
 public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
     protected final ClientSettings clientSettings;
+
     protected final Logger logger;
     protected final TikTokEventObserver tikTokEventHandler;
     protected final List<TikTokEventListener> listeners;
+    protected Consumer<TikTokMapper> onCustomMappings;
 
     public TikTokLiveClientBuilder(String userName) {
         this.tikTokEventHandler = new TikTokEventObserver();
@@ -75,10 +87,18 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         this.clientSettings.setHostName(userName);
         this.logger = Logger.getLogger(TikTokLive.class.getSimpleName() + " " + userName);
         this.listeners = new ArrayList<>();
+        this.onCustomMappings = (e) -> {
+        };
     }
 
-    public TikTokLiveClientBuilder configure(Consumer<ClientSettings> consumer) {
-        consumer.accept(clientSettings);
+    public LiveClientBuilder onMapping(Consumer<TikTokMapper> onCustomMappings) {
+        this.onCustomMappings = onCustomMappings;
+        return this;
+    }
+
+
+    public TikTokLiveClientBuilder configure(Consumer<ClientSettings> onConfigure) {
+        onConfigure.accept(clientSettings);
         return this;
     }
 
@@ -102,8 +122,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
             throw new TikTokLiveException("HostName can not be null");
         }
 
-        if (clientSettings.getHostName().startsWith("@"))
-        {
+        if (clientSettings.getHostName().startsWith("@")) {
             clientSettings.setHostName(clientSettings.getHostName().substring(1));
         }
 
@@ -130,11 +149,9 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
         logger.setLevel(clientSettings.getLogLevel());
 
-        if (clientSettings.isPrintToConsole() && clientSettings.getLogLevel() == Level.OFF) {
-            logger.setLevel(Level.ALL);
+        if (!clientSettings.isPrintToConsole()) {
+            logger.setLevel(Level.OFF);
         }
-
-
     }
 
     public LiveClient build() {
@@ -145,23 +162,18 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
         var listenerManager = new TikTokListenersManager(listeners, tikTokEventHandler);
         var cookieJar = new TikTokCookieJar();
-        var requestFactory = new TikTokHttpRequestFactory(cookieJar);
+        var requestFactory = new TikTokHttpRequestFactory(cookieJar, tikTokEventHandler);
         var apiClient = new TikTokHttpClient(cookieJar, requestFactory);
         var apiService = new TikTokApiService(apiClient, logger, clientSettings);
-        var giftManager = new TikTokGiftManager();
-        var eventMapper = new TikTokGenericEventMapper();
-        var giftHandler = new TikTokGiftEventHandler(giftManager);
+        var giftManager = new TikTokGiftManager(logger);
+        var eventsMapper = createMapper(giftManager, tiktokRoomInfo);
+        var messageHandler = new TikTokMessageHandler(tikTokEventHandler, eventsMapper);
 
-        var webResponseHandler = new TikTokMessageHandlerRegistration(tikTokEventHandler,
-                tiktokRoomInfo,
-                eventMapper,
-                giftHandler
-                );
 
-        var webSocketClient = new TikTokWebSocketClient(logger,
+        var webSocketClient = new TikTokWebSocketClient(
                 cookieJar,
                 clientSettings,
-                webResponseHandler,
+                messageHandler,
                 tikTokEventHandler);
 
         return new TikTokLiveClient(tiktokRoomInfo,
@@ -174,6 +186,93 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
                 logger);
     }
 
+    public TikTokLiveMapper createMapper(GiftManager giftManager, TikTokRoomInfo roomInfo) {
+        var eventMapper = new TikTokGenericEventMapper();
+        var mapper = new TikTokLiveMapper(new TikTokLiveMapperHelper(eventMapper));
+
+        //ConnectionEvents events
+        var commonHandler = new TikTokCommonEventHandler();
+        var giftHandler = new TikTokGiftEventHandler(giftManager);
+        var roomInfoHandler = new TikTokRoomInfoEventHandler(roomInfo);
+        var socialHandler = new TikTokSocialMediaEventHandler(roomInfo);
+
+
+        mapper.forMessage(WebcastControlMessage.class, commonHandler::handleWebcastControlMessage);
+
+        //Room status events
+        mapper.forMessage(WebcastLiveIntroMessage.class, roomInfoHandler::handleIntro);
+        mapper.forMessage(WebcastRoomUserSeqMessage.class, roomInfoHandler::handleUserRanking);
+        mapper.forMessage(WebcastCaptionMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastCaptionMessage.class);
+            return MappingResult.of(messageObject, new TikTokCaptionEvent(messageObject));
+        });
+
+
+        //User Interactions events
+        mapper.forMessage(WebcastChatMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
+            return MappingResult.of(messageObject, new TikTokCommentEvent(messageObject));
+        });
+        mapper.forMessage(WebcastSubNotifyMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastSubNotifyMessage.class);
+            return MappingResult.of(messageObject, new TikTokSubscribeEvent(messageObject));
+        });
+        mapper.forMessage(WebcastEmoteChatMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastEmoteChatMessage.class);
+            return MappingResult.of(messageObject, new TikTokEmoteEvent(messageObject));
+        });
+        mapper.forMessage(WebcastQuestionNewMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastQuestionNewMessage.class);
+            return MappingResult.of(messageObject, new TikTokQuestionEvent(messageObject));
+        });
+
+        mapper.forMessage(WebcastLikeMessage.class, roomInfoHandler::handleLike);
+        mapper.forMessage(WebcastGiftMessage.class, giftHandler::handleGifts);
+        mapper.forMessage(WebcastSocialMessage.class, socialHandler::handle);
+        mapper.forMessage(WebcastMemberMessage.class, roomInfoHandler::handleMemberMessage);
+
+
+        //Host Interaction events
+        mapper.forMessage(WebcastPollMessage.class, commonHandler::handlePollEvent);
+        mapper.forMessage(WebcastRoomPinMessage.class, commonHandler::handlePinMessage);
+        mapper.forMessage(WebcastChatMessage.class, (inputBytes, messageName, mapperHelper) ->
+        {
+            var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
+            return MappingResult.of(messageObject, new TikTokCommentEvent(messageObject));
+        });
+
+
+        //LinkMic events
+        // mapper.webcastObjectToConstructor(WebcastLinkMicBattle.class, TikTokLinkMicBattleEvent.class);
+        //  mapper.webcastObjectToConstructor(WebcastLinkMicArmies.class, TikTokLinkMicArmiesEvent.class);
+        //  mapper.webcastObjectToConstructor(WebcastLinkMicMethod.class, TikTokLinkMicMethodEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastLinkMicFanTicketMethod.class, TikTokLinkMicFanTicketEvent.class);
+
+        //Rank events
+        //   mapper.webcastObjectToConstructor(WebcastRankTextMessage.class, TikTokRankTextEvent.class);
+        //  mapper.webcastObjectToConstructor(WebcastRankUpdateMessage.class, TikTokRankUpdateEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastHourlyRankMessage.class, TikTokRankUpdateEvent.class);
+
+        //Others events
+        //  mapper.webcastObjectToConstructor(WebcastInRoomBannerMessage.class, TikTokInRoomBannerEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastMsgDetectMessage.class, TikTokDetectEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastBarrageMessage.class, TikTokBarrageEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastUnauthorizedMemberMessage.class, TikTokUnauthorizedMemberEvent.class);
+        //  mapper.webcastObjectToConstructor(WebcastOecLiveShoppingMessage.class, TikTokShopEvent.class);
+        //   mapper.webcastObjectToConstructor(WebcastImDeleteMessage.class, TikTokIMDeleteEvent.class);
+        //  mapper.bytesToEvents(WebcastEnvelopeMessage.class, commonHandler::handleEnvelop);
+
+
+        onCustomMappings.accept(mapper);
+        return mapper;
+    }
+
+
     public LiveClient buildAndConnect() {
         var client = build();
         client.connect();
@@ -184,12 +283,20 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return build().connectAsync();
     }
 
+
     public TikTokLiveClientBuilder onUnhandledSocial(
             EventConsumer<TikTokUnhandledSocialEvent> event) {
         tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
         return this;
     }
 
+    //  @Override
+    public LiveClientBuilder onChest(EventConsumer<TikTokChestEvent> event) {
+        tikTokEventHandler.subscribe(TikTokChestEvent.class, event);
+        return this;
+    }
+
+
     public TikTokLiveClientBuilder onLinkMicFanTicket(
             EventConsumer<TikTokLinkMicFanTicketEvent> event) {
         tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
@@ -239,16 +346,31 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return this;
     }
 
-    public TikTokLiveClientBuilder onRoom(EventConsumer<TikTokRoomEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomEvent.class, event);
+    @Override
+    public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> event) {
+        tikTokEventHandler.subscribe(eventClass, event);
         return this;
     }
 
+
+    @Override
+    public LiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
+        tikTokEventHandler.subscribe(TikTokRoomInfoEvent.class, event);
+        return this;
+    }
+
+
     public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
         tikTokEventHandler.subscribe(TikTokLivePausedEvent.class, event);
         return this;
     }
 
+    @Override
+    public LiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
+        tikTokEventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
+        return this;
+    }
+
     public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
         tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
         return this;
@@ -321,15 +443,14 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return this;
     }
 
-    public TikTokLiveClientBuilder onRoomUserInfo(
-            EventConsumer<TikTokRoomUserInfoEvent> event) {
-        tikTokEventHandler.subscribe(TikTokRoomUserInfoEvent.class, event);
+    public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
+        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
         return this;
     }
 
-
-    public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
-        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
+    @Override
+    public LiveClientBuilder onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
+        tikTokEventHandler.subscribe(TikTokHttpResponseEvent.class, action);
         return this;
     }
 

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

@@ -22,28 +22,52 @@
  */
 package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.tiktok.data.models.Picture;
+import io.github.jwdeveloper.tiktok.data.models.RankingUser;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
 import io.github.jwdeveloper.tiktok.models.ConnectionState;
 import io.github.jwdeveloper.tiktok.live.LiveRoomInfo;
 import lombok.Data;
 
+import java.util.LinkedList;
+import java.util.List;
+
 @Data
-public class TikTokRoomInfo implements LiveRoomInfo
-{
+public class TikTokRoomInfo implements LiveRoomInfo {
+    private String roomId;
 
     private int likesCount;
 
     private int viewersCount;
 
-    private String roomId;
+    private int totalViewersCount;
 
     private boolean ageRestricted;
 
+    private User host;
+
+    private List<RankingUser> usersRanking = new LinkedList<>();
+
     private String hostName;
 
+    private String title;
+
+    private String language = "en";
+
     private ConnectionState connectionState = ConnectionState.DISCONNECTED;
 
-    public boolean hasConnectionState(ConnectionState state)
-    {
+    public boolean hasConnectionState(ConnectionState state) {
         return connectionState == state;
     }
+
+    @Override
+    public User getHostUser() {
+        return host;
+    }
+
+    public void updateRanking(List<RankingUser> rankingUsers) {
+        usersRanking.clear();
+        usersRanking.addAll(rankingUsers);
+    }
+
 }

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

@@ -28,18 +28,22 @@ import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.live.GiftManager;
 import sun.misc.Unsafe;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.logging.Logger;
 
 public class TikTokGiftManager implements GiftManager {
 
     private final Map<Integer, Gift> indexById;
     private final Map<String, Gift> indexByName;
+    private final Logger logger;
 
-    public TikTokGiftManager() {
+    public TikTokGiftManager(Logger logger)
+    {
         indexById = new HashMap<>();
         indexByName = new HashMap<>();
+        this.logger = logger;
         init();
     }
 
@@ -66,6 +70,7 @@ public class TikTokGiftManager implements GiftManager {
             field.set(enumInstance, name);
 
 
+         //   EnumSet
             field = Gift.class.getDeclaredField("diamondCost");
             field.setAccessible(true);
             field.set(enumInstance, diamondCost);

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

@@ -23,47 +23,30 @@
 package io.github.jwdeveloper.tiktok.handlers;
 
 
+import io.github.jwdeveloper.tiktok.data.dto.MessageMetaData;
 import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketMessageEvent;
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketResponseEvent;
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandledMessageEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageException;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.mappers.TikTokGenericEventMapper;
+import io.github.jwdeveloper.tiktok.mappers.TikTokLiveMapper;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 import io.github.jwdeveloper.tiktok.utils.Stopwatch;
 
 import java.time.Duration;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
 
 
-public abstract class TikTokMessageHandler {
+public class TikTokMessageHandler {
 
-    private final Map<String, io.github.jwdeveloper.tiktok.handler.TikTokMessageHandler> handlers;
     private final TikTokEventObserver tikTokEventHandler;
-    protected final TikTokGenericEventMapper mapper;
+    private final TikTokLiveMapper mapper;
 
-    public TikTokMessageHandler(TikTokEventObserver tikTokEventHandler, TikTokGenericEventMapper mapper) {
-        handlers = new HashMap<>();
+    public TikTokMessageHandler(TikTokEventObserver tikTokEventHandler, TikTokLiveMapper mapper) {
         this.tikTokEventHandler = tikTokEventHandler;
         this.mapper = mapper;
     }
 
-    public void registerMapping(Class<?> clazz, Function<byte[], TikTokEvent> func) {
-        handlers.put(clazz.getSimpleName(), messagePayload -> List.of(func.apply(messagePayload)));
-    }
-
-    public void registerMappings(Class<?> clazz, Function<byte[], List<TikTokEvent>> func) {
-        handlers.put(clazz.getSimpleName(), func::apply);
-    }
-
-    public void registerMapping(Class<?> input, Class<?> output) {
-        registerMapping(input, (e) -> mapper.mapToEvent(input, output, e));
-    }
 
     public void handle(LiveClient client, WebcastResponse webcastResponse) {
         tikTokEventHandler.publish(client, new TikTokWebsocketResponseEvent(webcastResponse));
@@ -79,19 +62,18 @@ public abstract class TikTokMessageHandler {
 
     public void handleSingleMessage(LiveClient client, WebcastResponse.Message message) throws Exception {
         var messageClassName = message.getMethod();
-        if (!handlers.containsKey(messageClassName)) {
+        if (!mapper.isRegistered(messageClassName)) {
             tikTokEventHandler.publish(client, new TikTokWebsocketUnhandledMessageEvent(message));
             return;
         }
-        var handler = handlers.get(messageClassName);
         var stopwatch = new Stopwatch();
         stopwatch.start();
-        var events = handler.handle(message.getPayload().toByteArray());
+        var events = mapper.handleMapping(messageClassName, message.getPayload().toByteArray());
         var handlingTimeInMs = stopwatch.stop();
-        var metadata = new TikTokWebsocketMessageEvent.MetaData(Duration.ofNanos(handlingTimeInMs));
+        var metadata = new MessageMetaData(Duration.ofNanos(handlingTimeInMs));
 
         for (var event : events) {
-            tikTokEventHandler.publish(client, new TikTokWebsocketMessageEvent(event, message, metadata));
+            tikTokEventHandler.publish(client, new TikTokWebsocketMessageEvent(message, event, metadata));
             tikTokEventHandler.publish(client, event);
         }
     }

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

@@ -1,191 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.handlers;
-
-import io.github.jwdeveloper.tiktok.TikTokRoomInfo;
-import io.github.jwdeveloper.tiktok.data.events.*;
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEndEvent;
-import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEvent;
-import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollStartEvent;
-import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollUpdateEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomPinEvent;
-import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomUserInfoEvent;
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokFollowEvent;
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokShareEvent;
-import io.github.jwdeveloper.tiktok.data.models.Text;
-import io.github.jwdeveloper.tiktok.handlers.events.TikTokGiftEventHandler;
-import io.github.jwdeveloper.tiktok.mappers.TikTokGenericEventMapper;
-import io.github.jwdeveloper.tiktok.messages.webcast.*;
-import io.github.jwdeveloper.tiktok.models.SocialTypes;
-import lombok.SneakyThrows;
-
-import java.util.regex.Pattern;
-
-public class TikTokMessageHandlerRegistration extends TikTokMessageHandler {
-
-    private final TikTokRoomInfo roomInfo;
-    private final TikTokGiftEventHandler giftHandler;
-    private final Pattern socialMediaPattern = Pattern.compile("pm_mt_guidance_viewer_([0-9]+)_share");
-
-    public TikTokMessageHandlerRegistration(TikTokEventObserver tikTokEventHandler,
-                                            TikTokRoomInfo roomInfo,
-                                            TikTokGenericEventMapper genericTikTokEventMapper,
-                                            TikTokGiftEventHandler tikTokGiftEventHandler) {
-        super(tikTokEventHandler, genericTikTokEventMapper);
-        this.giftHandler = tikTokGiftEventHandler;
-        this.roomInfo = roomInfo;
-        init();
-    }
-
-    public void init() {
-
-        //ConnectionEvents events
-        registerMapping(WebcastControlMessage.class, this::handleWebcastControlMessage);
-        registerMapping(WebcastSystemMessage.class, TikTokRoomEvent.class);
-
-
-        //Room status events
-        registerMapping(WebcastLiveIntroMessage.class, TikTokRoomEvent.class);
-        registerMapping(WebcastRoomUserSeqMessage.class, this::handleRoomUserSeqMessage);
-        registerMapping(RoomMessage.class, TikTokRoomEvent.class);
-        registerMapping(WebcastRoomMessage.class, TikTokRoomEvent.class);
-        registerMapping(WebcastCaptionMessage.class, TikTokCaptionEvent.class);
-
-        //User Interactions events
-        registerMapping(WebcastChatMessage.class, TikTokCommentEvent.class);
-        registerMapping(WebcastLikeMessage.class, this::handleLike);
-        registerMappings(WebcastGiftMessage.class, giftHandler::handleGift);
-        registerMapping(WebcastSocialMessage.class, this::handleSocialMedia);
-        registerMapping(WebcastMemberMessage.class, this::handleMemberMessage);
-
-        //Host Interaction events
-        registerMapping(WebcastPollMessage.class, this::handlePollEvent);
-        registerMapping(WebcastRoomPinMessage.class, this::handlePinMessage);
-        registerMapping(WebcastGoalUpdateMessage.class, TikTokGoalUpdateEvent.class);
-
-        //LinkMic events
-        registerMapping(WebcastLinkMicBattle.class, TikTokLinkMicBattleEvent.class);
-        registerMapping(WebcastLinkMicArmies.class, TikTokLinkMicArmiesEvent.class);
-        registerMapping(WebcastLinkMicMethod.class, TikTokLinkMicMethodEvent.class);
-        registerMapping(WebcastLinkMicFanTicketMethod.class, TikTokLinkMicFanTicketEvent.class);
-
-        //Rank events
-        registerMapping(WebcastRankTextMessage.class, TikTokRankTextEvent.class);
-        registerMapping(WebcastRankUpdateMessage.class, TikTokRankUpdateEvent.class);
-        registerMapping(WebcastHourlyRankMessage.class, TikTokRankUpdateEvent.class);
-
-        //Others events
-        registerMapping(WebcastInRoomBannerMessage.class, TikTokInRoomBannerEvent.class);
-        registerMapping(WebcastMsgDetectMessage.class, TikTokDetectEvent.class);
-        registerMapping(WebcastBarrageMessage.class, TikTokBarrageEvent.class);
-        registerMapping(WebcastUnauthorizedMemberMessage.class, TikTokUnauthorizedMemberEvent.class);
-        registerMapping(WebcastOecLiveShoppingMessage.class, TikTokShopEvent.class);
-        registerMapping(WebcastImDeleteMessage.class, TikTokIMDeleteEvent.class);
-        registerMapping(WebcastQuestionNewMessage.class, TikTokQuestionEvent.class);
-        registerMapping(WebcastEnvelopeMessage.class, TikTokEnvelopeEvent.class);
-        registerMapping(WebcastSubNotifyMessage.class, TikTokSubNotifyEvent.class);
-        registerMapping(WebcastEmoteChatMessage.class, TikTokEmoteEvent.class);
-    }
-
-
-    @SneakyThrows
-    private TikTokEvent handleWebcastControlMessage(byte[] msg) {
-        var message = WebcastControlMessage.parseFrom(msg);
-        return switch (message.getAction()) {
-            case STREAM_PAUSED -> new TikTokLivePausedEvent();
-            case STREAM_ENDED -> new TikTokLiveEndedEvent();
-            default -> new TikTokUnhandledControlEvent(message);
-        };
-    }
-
-
-    @SneakyThrows
-    private TikTokEvent handleSocialMedia(byte[] msg) {
-        var message = WebcastSocialMessage.parseFrom(msg);
-
-        var socialType = Text.map(message.getCommon().getDisplayText()).getKey();
-        var matcher = socialMediaPattern.matcher(socialType);
-
-        if (matcher.find()) {
-            var value = matcher.group(1);
-            var number = Integer.parseInt(value);
-            return new TikTokShareEvent(message, number);
-        }
-
-        return switch (socialType) {
-            case SocialTypes.LikeType -> new TikTokLikeEvent(message, roomInfo.getLikesCount());
-            case SocialTypes.FollowType -> new TikTokFollowEvent(message);
-            case SocialTypes.ShareType -> new TikTokShareEvent(message);
-            case SocialTypes.JoinType -> new TikTokJoinEvent(message, roomInfo.getViewersCount());
-            default -> new TikTokUnhandledSocialEvent(message);
-        };
-    }
-
-    @SneakyThrows
-    private TikTokEvent handleMemberMessage(byte[] msg) {
-        var message = WebcastMemberMessage.parseFrom(msg);
-        return switch (message.getAction()) {
-            case JOINED -> new TikTokJoinEvent(message);
-            case SUBSCRIBED -> new TikTokSubscribeEvent(message);
-            default -> new TikTokUnhandledMemberEvent(message);
-        };
-    }
-
-    private TikTokEvent handleRoomUserSeqMessage(byte[] msg) {
-        var event = (TikTokRoomUserInfoEvent) mapper.mapToEvent(WebcastRoomUserSeqMessage.class, TikTokRoomUserInfoEvent.class, msg);
-        roomInfo.setViewersCount(event.getTotalUsers());
-        return event;
-    }
-
-    private TikTokEvent handleLike(byte[] msg) {
-        var event = (TikTokLikeEvent) mapper.mapToEvent(WebcastLikeMessage.class, TikTokLikeEvent.class, msg);
-        roomInfo.setLikesCount(event.getTotalLikes());
-        return event;
-    }
-
-    @SneakyThrows
-    private TikTokEvent handlePinMessage(byte[] msg) {
-        var pinMessage = WebcastRoomPinMessage.parseFrom(msg);
-        var chatMessage = WebcastChatMessage.parseFrom(pinMessage.getPinnedMessage());
-        var chatEvent = new TikTokCommentEvent(chatMessage);
-        return new TikTokRoomPinEvent(pinMessage, chatEvent);
-    }
-
-    //TODO Probably not working
-    @SneakyThrows
-    private TikTokEvent handlePollEvent(byte[] msg) {
-        var poolMessage = WebcastPollMessage.parseFrom(msg);
-        return switch (poolMessage.getMessageType()) {
-            case 0 -> new TikTokPollStartEvent(poolMessage);
-            case 1 -> new TikTokPollEndEvent(poolMessage);
-            case 2 -> new TikTokPollUpdateEvent(poolMessage);
-            default -> new TikTokPollEvent(poolMessage);
-        };
-    }
-
-
-}

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

@@ -22,15 +22,17 @@
  */
 package io.github.jwdeveloper.tiktok.http;
 
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
 import io.github.jwdeveloper.tiktok.ClientSettings;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.data.dto.TikTokUserInfo;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveOfflineHostException;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
 import io.github.jwdeveloper.tiktok.live.LiveRoomMeta;
 import io.github.jwdeveloper.tiktok.mappers.LiveRoomMetaMapper;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 
-import javax.script.ScriptEngineManager;
 import java.util.HashMap;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;
@@ -47,88 +49,80 @@ public class TikTokApiService {
     }
 
 
-    public void updateSessionId()
-    {
-        if(clientSettings.getSessionId() == null)
-        {
+    public void updateSessionId() {
+        if (clientSettings.getSessionId() == null) {
             return;
         }
-        if(clientSettings.getSessionId().isEmpty())
-        {
-          return;
+        if (clientSettings.getSessionId().isEmpty()) {
+            return;
         }
         tiktokHttpClient.setSessionId(clientSettings.getSessionId());
     }
 
-    public boolean sendMessage(String message, String sessionId) {
-        if (sessionId.isEmpty()) {
-            throw new TikTokLiveException("Session ID must not be Empty");
-        }
-        var roomId = clientSettings.getClientParameters().get("room_id");
-        if (roomId == null) {
-            throw new TikTokLiveException("Room ID must not be Empty");
-        }
-        logger.info("Sending message to chat");
-        try {
-            var params = new HashMap<String, Object>(clientSettings.getClientParameters());
-            params.put("content", message);
-            params.put("channel", "tiktok_web");
-            params.remove("cursor");
-            tiktokHttpClient.setSessionId(sessionId);
-            tiktokHttpClient.postMessageToChat(params);
-            return true;
-        } catch (Exception e) {
-            throw new TikTokLiveRequestException("Failed to fetch room id from WebCast, see stacktrace for more info.", e);
-        }
+    public String fetchRoomId(String userName) {
+        var userInfo = fetchUserInfoFromTikTokApi(userName);
+        clientSettings.getClientParameters().put("room_id", userInfo.getRoomId());
+        logger.info("RoomID -> " + userInfo.getRoomId());
+        return userInfo.getRoomId();
     }
 
-    public String fetchRoomId(String userName) {
-        logger.info("Fetching room ID");
-        String html;
+    public TikTokUserInfo fetchUserInfoFromTikTokApi(String userName) {
+
+        var params = new HashMap<>(clientSettings.getClientParameters());
+        params.put("uniqueId", userName);
+        params.put("sourceType", 54);
+        JsonObject roomData = null;
         try {
-            html = tiktokHttpClient.getLivestreamPage(userName);
-        }
-        catch (Exception e)
-        {
-            throw new TikTokLiveRequestException("Failed to fetch room id from WebCast, see stacktrace for more info.", e);
+            roomData = tiktokHttpClient.getJsonFromTikTokApi("api-live/user/room/", params);
+        } catch (Exception e) {
+
+
+            throw new TikTokLiveRequestException("Failed to fetch  pre connection room information, it happens when TikTok temporary blocks you. Try to connect again in few minutes");
         }
 
-        var firstPattern = Pattern.compile("room_id=([0-9]*)");
-        var firstMatcher = firstPattern.matcher(html);
-        var id = "";
+        var message = roomData.get("message").getAsString();
 
-        if (firstMatcher.find()) {
-            id = firstMatcher.group(1);
-        } else {
-            var secondPattern = Pattern.compile("\"roomId\":\"([0-9]*)\"");
-            var secondMatcher = secondPattern.matcher(html);
-
-            if (secondMatcher.find()) {
-                id = secondMatcher.group(1);
-            }
+        if (message.equals("params_error")) {
+            throw new TikTokLiveRequestException("fetchRoomIdFromTiktokApi -> Unable to fetch roomID, contact with developer");
         }
-
-        if (id.isEmpty()) {
-            throw new TikTokLiveOfflineHostException("Unable to fetch room ID, live host could be offline or name is misspelled");
+        if (message.equals("user_not_found")) {
+            return new TikTokUserInfo(TikTokUserInfo.UserStatus.NotFound, "");
         }
+        //live -> status 2
+        //live paused -> 3
+        //not live -> status 4
+        var data = roomData.getAsJsonObject("data");
+        var user = data.getAsJsonObject("user");
+        var roomId = user.get("roomId").getAsString();
+        var status = user.get("status").getAsInt();
 
-        clientSettings.getClientParameters().put("room_id", id);
-        logger.info("RoomID -> " + id);
-        return id;
+        var statusEnum = switch (status) {
+            case 2 -> TikTokUserInfo.UserStatus.Live;
+            case 3 -> TikTokUserInfo.UserStatus.LivePaused;
+            case 4 -> TikTokUserInfo.UserStatus.Offline;
+            default -> TikTokUserInfo.UserStatus.NotFound;
+        };
+
+        return new TikTokUserInfo(statusEnum, roomId);
     }
 
 
     public LiveRoomMeta fetchRoomInfo() {
         logger.info("Fetching RoomInfo");
         try {
-            var response = tiktokHttpClient.getJObjectFromWebcastAPI("room/info/", clientSettings.getClientParameters());
+            var response = tiktokHttpClient.getJsonFromWebcastApi("room/info/", clientSettings.getClientParameters());
+            if (!response.has("data")) {
+                var gson = new GsonBuilder().setPrettyPrinting().create();
+                var json = gson.toJson(response);
+                throw new TikTokLiveRequestException("room info response does not contains data field: \n"+ json);
+            }
+
             var mapper = new LiveRoomMetaMapper();
             var liveRoomMeta = mapper.map(response);
             logger.info("RoomInfo status -> " + liveRoomMeta.getStatus());
             return liveRoomMeta;
-        } catch (Exception e)
-        {
-            throw new TikTokLiveRequestException("Failed to fetch room info from WebCast, see stacktrace for more info.", e);
+        } catch (Exception e) {
+            throw new TikTokLiveRequestException("Failed to fetch room info from WebCast server, see stacktrace for more info.", e);
         }
     }
 
@@ -136,12 +130,12 @@ public class TikTokApiService {
 
         logger.info("Fetching ClientData");
         try {
-            var response = tiktokHttpClient.getSigningServerMessage("im/fetch/", clientSettings.getClientParameters());
+            var response = tiktokHttpClient.getSigningServerResponse("im/fetch/", clientSettings.getClientParameters());
             clientSettings.getClientParameters().put("cursor", response.getCursor());
             clientSettings.getClientParameters().put("internal_ext", response.getInternalExt());
             return response;
         } catch (Exception e) {
-            throw new TikTokLiveRequestException("Failed to fetch client data", e);
+            throw new TikTokLiveRequestException("Failed to fetch live websocket connection data", e);
         }
     }
 }

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.http;
+
+import io.github.jwdeveloper.tiktok.ClientSettings;
+import io.github.jwdeveloper.tiktok.Constants;
+import io.github.jwdeveloper.tiktok.data.dto.TikTokUserInfo;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
+import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+
+public class TikTokDataChecker {
+
+    public CompletableFuture<Boolean> isOnlineAsync(String hostName) {
+        return CompletableFuture.supplyAsync(() -> isOnline(hostName));
+    }
+
+    public CompletableFuture<Boolean> isHostNameValidAsync(String hostName) {
+        return CompletableFuture.supplyAsync(() -> isOnline(hostName));
+    }
+
+    public boolean isOnline(String hostName) {
+        var data = getApiService().fetchUserInfoFromTikTokApi(hostName);
+        return data.getUserStatus() == TikTokUserInfo.UserStatus.Live ||
+                data.getUserStatus() == TikTokUserInfo.UserStatus.LivePaused;
+    }
+
+    public boolean isHostNameValid(String hostName) {
+        var data = getApiService().fetchUserInfoFromTikTokApi(hostName);
+        return data.getUserStatus() != TikTokUserInfo.UserStatus.NotFound;
+    }
+
+    public TikTokApiService getApiService() {
+        var jar = new TikTokCookieJar();
+        var factory = new TikTokHttpRequestFactory(jar,new TikTokEventObserver());
+        var client = new TikTokHttpClient(jar, factory);
+        var settings = new ClientSettings();
+        settings.setClientParameters(Constants.DefaultClientParams());
+        var apiService = new TikTokApiService(client, Logger.getGlobal(), settings);
+        return apiService;
+    }
+
+}

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

@@ -60,20 +60,23 @@ public class TikTokHttpClient {
         return get;
     }
 
-    public String postMessageToChat(Map<String,Object> parameters)
+    public JsonObject getJsonFromTikTokApi(String path, Map<String,Object> params)
     {
-        var get = postRequest(Constants.TIKTOK_URL_WEBCAST + "room/chat/", parameters);
-        return get;
-    }
-
-    public JsonObject getJObjectFromWebcastAPI(String path, Map<String, Object> parameters) {
-        var get = getRequest(Constants.TIKTOK_URL_WEBCAST + path, parameters);
+        var get = getRequest(Constants.TIKTOK_URL_WEB + path, params);
         var json = JsonParser.parseString(get);
         var jsonObject = json.getAsJsonObject();
         return jsonObject;
     }
 
-    public WebcastResponse getSigningServerMessage(String path, Map<String, Object> parameters) {
+    public JsonObject getJsonFromWebcastApi(String path, Map<String, Object> parameters) {
+        var get = getRequest(Constants.TIKTOK_URL_WEBCAST + path, parameters);
+
+        var json = JsonParser.parseString(get);
+        var jsonObject = json.getAsJsonObject();
+        return jsonObject;
+    }
+
+    public WebcastResponse getSigningServerResponse(String path, Map<String, Object> parameters) {
         var bytes = getSignRequest(Constants.TIKTOK_URL_WEBCAST + path, parameters);
         try {
             return WebcastResponse.parseFrom(bytes);
@@ -88,7 +91,6 @@ public class TikTokHttpClient {
         if (parameters == null) {
             parameters = new HashMap<>();
         }
-        System.out.println("RomMID: "+parameters.get("room_id"));
         var request = requestFactory.setQueries(parameters);
         return request.post(url);
     }

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

@@ -24,7 +24,10 @@ package io.github.jwdeveloper.tiktok.http;
 
 
 import io.github.jwdeveloper.tiktok.Constants;
+import io.github.jwdeveloper.tiktok.data.events.http.TikTokHttpResponseEvent;
+import io.github.jwdeveloper.tiktok.data.models.http.HttpData;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveRequestException;
+import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
 import lombok.SneakyThrows;
 
 import java.net.CookieManager;
@@ -45,51 +48,55 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest {
     private final Map<String, String> defaultHeaders;
     private final TikTokCookieJar tikTokCookieJar;
     private final HttpClient client;
+    private final TikTokEventObserver eventHandler;
     private String query;
 
-    public TikTokHttpRequestFactory(TikTokCookieJar tikTokCookieJar) {
+    public TikTokHttpRequestFactory(TikTokCookieJar tikTokCookieJar, TikTokEventObserver eventHandler) {
         this.tikTokCookieJar = tikTokCookieJar;
         this.cookieManager = new CookieManager();
+        this.eventHandler = eventHandler;
         defaultHeaders = Constants.DefaultRequestHeaders();
         client = HttpClient.newBuilder()
                 .cookieHandler(cookieManager)
                 .connectTimeout(Duration.ofSeconds(2))
                 .build();
     }
+
     @SneakyThrows
     public String get(String url) {
         var uri = URI.create(url);
-        var request = HttpRequest.newBuilder().GET();
-        for (var header : defaultHeaders.entrySet())
-        {
-            if(header.getKey().equals("Connection") || header.getKey().equals("Accept-Encoding"))
-            {
+        var requestBuilder = HttpRequest.newBuilder().GET();
+
+        for (var header : defaultHeaders.entrySet()) {
+            if (header.getKey().equals("Connection") || header.getKey().equals("Accept-Encoding")) {
                 continue;
             }
-            request.setHeader(header.getKey(), header.getValue());
+            requestBuilder.setHeader(header.getKey(), header.getValue());
         }
         if (query != null) {
             var baseUri = uri.toString();
             var requestUri = URI.create(baseUri + "?" + query);
-            request.uri(requestUri);
+            requestBuilder.uri(requestUri);
+        } else {
+            requestBuilder.uri(uri);
         }
 
-        return getContent(request.build());
+        var result = requestBuilder.build();
+
+        return getContent(result);
     }
 
     @SneakyThrows
     public String post(String url) {
         var uri = URI.create(url);
         var request = HttpRequest.newBuilder().POST(HttpRequest.BodyPublishers.ofString(""));
-        for (var header : defaultHeaders.entrySet())
-        {
-            if(header.getKey().equals("Connection"))
-            {
+        for (var header : defaultHeaders.entrySet()) {
+            if (header.getKey().equals("Connection")) {
                 continue;
             }
             request.setHeader(header.getKey(), header.getValue());
         }
-        request.setHeader("Content-type","application/x-www-form-urlencoded; charset=UTF-8");
+        request.setHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
         request.setHeader("Cookie", tikTokCookieJar.parseCookies());
 
 
@@ -97,11 +104,8 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest {
             var baseUri = uri.toString();
             var requestUri = URI.create(baseUri + "?" + query);
             request.uri(requestUri);
-            System.out.println(requestUri.toString());
         }
 
-
-
         return getContent(request.build());
     }
 
@@ -118,7 +122,7 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest {
     public TikTokHttpRequest setQueries(Map<String, Object> queries) {
         if (queries == null)
             return this;
-        var testMap = new TreeMap<String,Object>(queries);
+        var testMap = new TreeMap<String, Object>(queries);
         query = String.join("&", testMap.entrySet().stream().map(x ->
         {
             var key = x.getKey();
@@ -136,6 +140,9 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest {
 
     private String getContent(HttpRequest request) throws Exception {
         var response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        var event = new TikTokHttpResponseEvent(response.uri().toString(), HttpData.map(request), HttpData.map(response));
+        eventHandler.publish(null, event);
         if (response.statusCode() == 404) {
             throw new TikTokLiveRequestException("Request responded with 404 NOT_FOUND");
         }
@@ -148,8 +155,6 @@ public class TikTokHttpRequestFactory implements TikTokHttpRequest {
         for (var cookie : cookies) {
             var split = cookie.split(";")[0].split("=");
             var uri = request.uri();
-
-
             var key = split[0];
             var value = split[1];
             tikTokCookieJar.set(key, value);

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

@@ -23,11 +23,10 @@
 package io.github.jwdeveloper.tiktok.listener;
 
 
-import io.github.jwdeveloper.tiktok.annotations.TikTokEventHandler;
+import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokEventListenerMethodException;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
-import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 
@@ -37,10 +36,10 @@ import java.util.HashMap;
 import java.util.List;
 
 public class TikTokListenersManager implements ListenersManager {
-    private final TikTokEventObserver eventObserver;
+    private final io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver eventObserver;
     private final List<ListenerBindingModel> bindingModels;
 
-    public TikTokListenersManager(List<TikTokEventListener> listeners, TikTokEventObserver tikTokEventHandler) {
+    public TikTokListenersManager(List<TikTokEventListener> listeners, io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver tikTokEventHandler) {
         this.eventObserver = tikTokEventHandler;
         this.bindingModels = new ArrayList<>(listeners.size());
         for (var listener : listeners) {
@@ -93,7 +92,7 @@ public class TikTokListenersManager implements ListenersManager {
         var clazz = listener.getClass();
         var methods = Arrays.stream(clazz.getDeclaredMethods()).filter(m ->
                 m.getParameterCount() == 2 &&
-                        m.isAnnotationPresent(TikTokEventHandler.class)).toList();
+                        m.isAnnotationPresent(TikTokEventObserver.class)).toList();
         var eventsMap = new HashMap<Class<?>, List<EventConsumer<?>>>();
         for (var method : methods) {
             var eventClazz = method.getParameterTypes()[1];

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

@@ -22,9 +22,15 @@
  */
 package io.github.jwdeveloper.tiktok.mappers;
 
+import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
+import io.github.jwdeveloper.tiktok.data.models.Picture;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.data.models.users.UserAttribute;
 import io.github.jwdeveloper.tiktok.live.LiveRoomMeta;
 
+import java.util.ArrayList;
+
 public class LiveRoomMetaMapper {
     /**
      * 0 - Unknown
@@ -46,15 +52,12 @@ public class LiveRoomMetaMapper {
             var status = data.get("status");
             var statusId = status.getAsInt();
             var statusValue = switch (statusId) {
-                case 0 -> LiveRoomMeta.LiveRoomStatus.HostNotFound;
                 case 2 -> LiveRoomMeta.LiveRoomStatus.HostOnline;
                 case 4 -> LiveRoomMeta.LiveRoomStatus.HostOffline;
-                default-> LiveRoomMeta.LiveRoomStatus.HostNotFound;
+                default -> LiveRoomMeta.LiveRoomStatus.HostNotFound;
             };
             liveRoomMeta.setStatus(statusValue);
-        }
-        else
-        {
+        } else {
             liveRoomMeta.setStatus(LiveRoomMeta.LiveRoomStatus.HostNotFound);
         }
 
@@ -63,6 +66,61 @@ public class LiveRoomMetaMapper {
             var restricted = element.get("restricted").getAsBoolean();
             liveRoomMeta.setAgeRestricted(restricted);
         }
+
+        if (data.has("title")) {
+            var element = data.get("title");
+            var title = element.getAsString();
+            liveRoomMeta.setTitie(title);
+        }
+
+        if (data.has("stats")) {
+            var statsElement = data.getAsJsonObject("stats");
+            var likeElement = statsElement.get("like_count");
+            var likes = likeElement.getAsInt();
+
+            var titalUsersElement = statsElement.get("total_user");
+            var totalUsers = titalUsersElement.getAsInt();
+
+
+            liveRoomMeta.setLikeCount(likes);
+            liveRoomMeta.setTotalViewers(totalUsers);
+        }
+
+        if(data.has("user_count"))
+        {
+            var element = data.get("user_count");
+            var viewers = element.getAsInt();
+            liveRoomMeta.setViewers(viewers);
+        }
+
+        if(data.has("owner"))
+        {
+            var element = data.getAsJsonObject("owner");
+            var user = getUser(element);
+            liveRoomMeta.setHost(user);
+        }
+
         return liveRoomMeta;
     }
+
+    public User getUser(JsonObject jsonElement)
+    {
+        var id = jsonElement.get("id").getAsLong();
+        var name = jsonElement.get("display_id").getAsString();
+        var profileName = jsonElement.get("nickname").getAsString();
+
+
+        var followElement =jsonElement.getAsJsonObject("follow_info");
+        var followers = followElement.get("follower_count").getAsInt();
+        var followingCount = followElement.get("following_count").getAsInt();
+
+
+        var pictureElement =jsonElement.getAsJsonObject("avatar_large");
+        var link = pictureElement.getAsJsonArray("url_list").get(1).getAsString();
+        var picture = new Picture(link);
+
+        var user = new User(id,name,profileName,picture,followers,followingCount,new ArrayList<>());
+        user.addAttribute(UserAttribute.LiveHost);
+        return user;
+    }
 }

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

@@ -74,7 +74,7 @@ public class TikTokGenericEventMapper {
         }
     }
 
-    private Method getParsingMethod(Class<?> input) throws NoSuchMethodException {
+    public Method getParsingMethod(Class<?> input) throws NoSuchMethodException {
         if (methodCache.containsKey(input)) {
             return methodCache.get(input);
         }

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

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.mappers;
+
+import com.google.protobuf.GeneratedMessageV3;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingAction;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class TikTokLiveMapper implements TikTokMapper {
+
+    private final Map<String, TikTokLiveMapperModel> mappers;
+    private final TikTokMapperHelper mapperUtils;
+
+    public TikTokLiveMapper(TikTokMapperHelper mapperUtils) {
+        this.mappers = new HashMap<>();
+        this.mapperUtils = mapperUtils;
+    }
+
+    @Override
+    public TikTokMapperModel forMessage(String messageName) {
+        if (!isRegistered(messageName)) {
+            var model = new TikTokLiveMapperModel(messageName);
+            mappers.put(messageName, model);
+        }
+        return mappers.get(messageName);
+    }
+
+    @Override
+    public TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName) {
+        return forMessage(mapperName.getSimpleName());
+    }
+
+    @Override
+    public TikTokMapperModel forMessage(String mapperName, MappingAction<MappingResult> onMapping) {
+        var model = forMessage(mapperName);
+        model.onMapping(onMapping);
+        return model;
+    }
+
+
+    @Override
+    public TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName, MappingAction<MappingResult> onMapping) {
+        var model = forMessage(mapperName);
+        model.onMapping(onMapping);
+        return model;
+    }
+
+    @Override
+    public TikTokMapperModel forMessage(Class<? extends GeneratedMessageV3> mapperName, Function<byte[], TikTokEvent> onMapping) {
+        return forMessage(mapperName, (inputBytes, messageName, mapperHelper) -> MappingResult.of(inputBytes, onMapping.apply(inputBytes)));
+    }
+
+
+    public boolean isRegistered(String mapperName) {
+        return mappers.containsKey(mapperName);
+    }
+
+    public <T extends GeneratedMessageV3> boolean isRegistered(Class<T> mapperName) {
+        return mappers.containsKey(mapperName.getSimpleName());
+    }
+    public List<TikTokEvent> handleMapping(String messageName, byte[] bytes) {
+        if (!isRegistered(messageName)) {
+            return List.of();
+        }
+        var mapperModel = mappers.get(messageName);
+
+        var inputBytes = mapperModel.getOnBeforeMapping().onMapping(bytes, messageName, mapperUtils);
+
+        var mappingResult = mapperModel.getOnMapping().onMapping(inputBytes, messageName, mapperUtils);
+
+        var afterMappingResult = mapperModel.getOnAfterMapping().apply(mappingResult);
+        return afterMappingResult;
+    }
+}

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

@@ -0,0 +1,60 @@
+package io.github.jwdeveloper.tiktok.mappers;
+
+import com.google.protobuf.GeneratedMessageV3;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokMessageMappingException;
+import io.github.jwdeveloper.tiktok.utils.JsonUtil;
+import io.github.jwdeveloper.tiktok.utils.ProtoBufferObject;
+import io.github.jwdeveloper.tiktok.utils.ProtocolUtils;
+
+public class TikTokLiveMapperHelper implements TikTokMapperHelper {
+    private final TikTokGenericEventMapper genericMapper;
+
+    public TikTokLiveMapperHelper(TikTokGenericEventMapper genericMapper) {
+        this.genericMapper = genericMapper;
+    }
+
+    @Override
+    public <T extends GeneratedMessageV3> T bytesToWebcastObject(byte[] bytes, Class<T> messageClass) {
+        try {
+            var parsingMethod = genericMapper.getParsingMethod(messageClass);
+            var sourceObject = parsingMethod.invoke(null, bytes);
+            return (T) sourceObject;
+        } catch (Exception e) {
+            throw new TikTokMessageMappingException(messageClass, "can't find parsing method", e);
+        }
+    }
+
+    @Override
+    public Object bytesToWebcastObject(byte[] bytes, String messageName) {
+        try {
+            var packageName = "io.github.jwdeveloper.tiktok.messages.webcast." + messageName;
+            var clazz = Class.forName(packageName);
+            return bytesToWebcastObject(bytes, (Class<? extends GeneratedMessageV3>) clazz);
+        } catch (Exception e) {
+            throw new TikTokMessageMappingException(messageName, e);
+        }
+    }
+
+    @Override
+    public boolean isMessageHasProtoClass(String messageName) {
+        try {
+            var packageName = "io.github.jwdeveloper.tiktok.messages.webcast." + messageName;
+            Class.forName(packageName);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    @Override
+    public ProtoBufferObject bytesToProtoBufferStructure(byte[] bytes) {
+        return ProtocolUtils.getProtocolBufferStructure(bytes);
+    }
+
+    @Override
+    public String toJson(Object obj) {
+        return JsonUtil.toJson(obj);
+    }
+
+
+}

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

@@ -0,0 +1,57 @@
+package io.github.jwdeveloper.tiktok.mappers;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingAction;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.function.Function;
+
+@Getter
+@Setter
+public class TikTokLiveMapperModel implements TikTokMapperModel {
+    @Getter
+    private String sourceMessageName;
+
+    private MappingAction<byte[]> onBeforeMapping;
+
+    private MappingAction<MappingResult> onMapping;
+
+    private Function<MappingResult, List<TikTokEvent>> onAfterMapping;
+
+    public TikTokLiveMapperModel(String sourceMessageName, MappingAction onMapping) {
+        this.sourceMessageName = sourceMessageName;
+        this.onBeforeMapping = (inputBytes, mesasgeName, mapperHelper) -> inputBytes;
+        this.onMapping = onMapping;
+        this.onAfterMapping = MappingResult::getEvents;
+    }
+
+    public TikTokLiveMapperModel(String sourceMessageName) {
+        this.sourceMessageName = sourceMessageName;
+        this.onBeforeMapping = (inputBytes, mesasgeName, mapperHelper) -> inputBytes;
+        this.onMapping = (inputBytes, mesasgeName, mapperHelper) -> MappingResult.of(inputBytes, List.of());
+        this.onAfterMapping = MappingResult::getEvents;
+    }
+
+    @Override
+    public TikTokMapperModel onBeforeMapping(MappingAction<byte[]> action) {
+        this.onBeforeMapping = action;
+        return this;
+    }
+
+    @Override
+    public TikTokMapperModel onMapping(MappingAction<MappingResult> action) {
+        this.onMapping = action;
+        return this;
+    }
+
+    @Override
+    public TikTokMapperModel onAfterMapping(Function<MappingResult, List<TikTokEvent>> action) {
+        this.onAfterMapping = action;
+        return this;
+    }
+
+
+}

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.mappers.handlers;
+
+public class TikTokChestEventHandler {
+}

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.mappers.handlers;
+
+import io.github.jwdeveloper.tiktok.data.events.*;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.envelop.TikTokChestEvent;
+import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEndEvent;
+import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollEvent;
+import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollStartEvent;
+import io.github.jwdeveloper.tiktok.data.events.poll.TikTokPollUpdateEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomPinEvent;
+import io.github.jwdeveloper.tiktok.data.models.chest.Chest;
+import io.github.jwdeveloper.tiktok.messages.enums.EnvelopeDisplay;
+import io.github.jwdeveloper.tiktok.messages.webcast.*;
+import lombok.SneakyThrows;
+
+import java.util.Collections;
+import java.util.List;
+
+public class TikTokCommonEventHandler
+{
+
+    @SneakyThrows
+    public TikTokEvent handleWebcastControlMessage(byte[] msg) {
+        var message = WebcastControlMessage.parseFrom(msg);
+        return switch (message.getAction()) {
+            case STREAM_PAUSED -> new TikTokLivePausedEvent();
+            case STREAM_ENDED -> new TikTokLiveEndedEvent();
+            case STREAM_UNPAUSED -> new TikTokLiveUnpausedEvent();
+            default -> new TikTokUnhandledControlEvent(message);
+        };
+    }
+
+    @SneakyThrows
+    public TikTokEvent handlePinMessage(byte[] msg) {
+        var pinMessage = WebcastRoomPinMessage.parseFrom(msg);
+        var chatMessage = WebcastChatMessage.parseFrom(pinMessage.getPinnedMessage());
+        var chatEvent = new TikTokCommentEvent(chatMessage);
+        return new TikTokRoomPinEvent(pinMessage, chatEvent);
+    }
+
+    //TODO Probably not working
+    @SneakyThrows
+    public TikTokEvent handlePollEvent(byte[] msg) {
+        var poolMessage = WebcastPollMessage.parseFrom(msg);
+        return switch (poolMessage.getMessageType()) {
+            case MESSAGETYPE_SUBSUCCESS -> new TikTokPollStartEvent(poolMessage);
+            case MESSAGETYPE_ANCHORREMINDER -> new TikTokPollEndEvent(poolMessage);
+            case MESSAGETYPE_ENTERROOMEXPIRESOON -> new TikTokPollUpdateEvent(poolMessage);
+            default -> new TikTokPollEvent(poolMessage);
+        };
+    }
+
+    @SneakyThrows
+    public List<TikTokEvent> handleEnvelop(byte[] data) {
+        var msg = WebcastEnvelopeMessage.parseFrom(data);
+        if (msg.getDisplay() != EnvelopeDisplay.EnvelopeDisplayNew) {
+            return Collections.emptyList();
+        }
+        var totalDiamonds = msg.getEnvelopeInfo().getDiamondCount();
+        var totalUsers = msg.getEnvelopeInfo().getPeopleCount();
+        var chest = new Chest(totalDiamonds, totalUsers);
+
+        return List.of(new TikTokChestEvent(chest, msg));
+    }
+
+}

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

@@ -20,7 +20,7 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-package io.github.jwdeveloper.tiktok.handlers.events;
+package io.github.jwdeveloper.tiktok.mappers.handlers;
 
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
@@ -28,9 +28,13 @@ import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
 import io.github.jwdeveloper.tiktok.data.models.Picture;
 import io.github.jwdeveloper.tiktok.data.models.gifts.Gift;
 import io.github.jwdeveloper.tiktok.data.models.gifts.GiftSendType;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.live.GiftManager;
+import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import lombok.SneakyThrows;
+import sun.misc.Unsafe;
 
 import java.util.HashMap;
 import java.util.List;
@@ -46,12 +50,25 @@ public class TikTokGiftEventHandler {
     }
 
     @SneakyThrows
-    public List<TikTokEvent> handleGift(byte[] msg) {
+    public MappingResult handleGifts(byte[] msg, String name, TikTokMapperHelper helper) {
         var currentMessage = WebcastGiftMessage.parseFrom(msg);
+        var gifts = handleGift(currentMessage);
+        return MappingResult.of(currentMessage,gifts);
+    }
+
+    public List<TikTokEvent> handleGift(WebcastGiftMessage currentMessage) {
         var userId = currentMessage.getUser().getId();
         var currentType = GiftSendType.fromNumber(currentMessage.getSendType());
         var containsPreviousMessage = giftsMessages.containsKey(userId);
 
+
+        //If gift is not streakable just return onGift event
+        if (currentMessage.getGift().getType() != 1) {
+            var comboEvent = getGiftComboEvent(currentMessage, GiftSendType.Finished);
+            var giftEvent = getGiftEvent(currentMessage);
+            return List.of(comboEvent, giftEvent);
+        }
+
         if (!containsPreviousMessage) {
             if (currentType == GiftSendType.Finished) {
                 return List.of(getGiftEvent(currentMessage));
@@ -81,6 +98,7 @@ public class TikTokGiftEventHandler {
         return List.of();
     }
 
+
     private TikTokGiftEvent getGiftEvent(WebcastGiftMessage message) {
         var gift = getGiftObject(message);
         return new TikTokGiftEvent(gift, message);
@@ -92,17 +110,36 @@ public class TikTokGiftEventHandler {
     }
 
     private Gift getGiftObject(WebcastGiftMessage giftMessage) {
-        var gift = giftManager.findById((int) giftMessage.getGiftId());
+        var giftId = (int) giftMessage.getGiftId();
+        var gift = giftManager.findById(giftId);
         if (gift == Gift.UNDEFINED) {
             gift = giftManager.findByName(giftMessage.getGift().getName());
         }
         if (gift == Gift.UNDEFINED) {
             gift = giftManager.registerGift(
-                    (int) giftMessage.getGift().getId(),
+                    giftId,
                     giftMessage.getGift().getName(),
                     giftMessage.getGift().getDiamondCount(),
                     Picture.map(giftMessage.getGift().getImage()));
         }
+
+        if (gift.getPicture().getLink().endsWith(".webp")) {
+            updatePicture(gift, giftMessage);
+        }
         return gift;
     }
+
+
+    private void updatePicture(Gift gift, WebcastGiftMessage webcastGiftMessage) {
+        try {
+            var picture = Picture.map(webcastGiftMessage.getGift().getImage());
+            var constructor = Unsafe.class.getDeclaredConstructors()[0];
+            constructor.setAccessible(true);
+            var field = Gift.class.getDeclaredField("picture");
+            field.setAccessible(true);
+            field.set(gift, picture);
+        } catch (Exception e) {
+            throw new TikTokLiveException("Unable to update picture in gift: " + gift.toString());
+        }
+    }
 }

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

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.mappers.handlers;
+
+import io.github.jwdeveloper.tiktok.TikTokRoomInfo;
+import io.github.jwdeveloper.tiktok.data.events.TikTokSubscribeEvent;
+import io.github.jwdeveloper.tiktok.data.events.TikTokUnhandledMemberEvent;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
+import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
+import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
+import io.github.jwdeveloper.tiktok.data.models.RankingUser;
+import io.github.jwdeveloper.tiktok.data.models.users.User;
+import io.github.jwdeveloper.tiktok.mappers.TikTokMapperHelper;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLikeMessage;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLiveIntroMessage;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastMemberMessage;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastRoomUserSeqMessage;
+import lombok.SneakyThrows;
+
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+public class TikTokRoomInfoEventHandler {
+    private final TikTokRoomInfo roomInfo;
+
+    public TikTokRoomInfoEventHandler(TikTokRoomInfo roomInfo) {
+        this.roomInfo = roomInfo;
+    }
+
+    public TikTokEvent handleRoomInfo(Consumer<TikTokRoomInfo> consumer) {
+        consumer.accept(roomInfo);
+        return new TikTokRoomInfoEvent(roomInfo);
+    }
+
+    @SneakyThrows
+    public TikTokEvent handleUserRanking(byte[] msg) {
+        var message = WebcastRoomUserSeqMessage.parseFrom(msg);
+        var totalUsers = message.getTotalUser();
+        var userRanking = message.getRanksListList().stream().map(RankingUser::new)
+                .sorted((ru1, ru2) -> Integer.compare(ru2.getScore(), ru1.getScore()))
+                .collect(Collectors.toList());
+
+        return handleRoomInfo(tikTokRoomInfo ->
+        {
+            tikTokRoomInfo.setTotalViewersCount(totalUsers);
+            tikTokRoomInfo.updateRanking(userRanking);
+        });
+    }
+
+    @SneakyThrows
+    public TikTokEvent handleIntro(byte[] msg) {
+        var message = WebcastLiveIntroMessage.parseFrom(msg);
+        var hostUser = User.map(message.getHost());
+        var language = message.getLanguage();
+
+        return handleRoomInfo(tikTokRoomInfo ->
+        {
+            if (tikTokRoomInfo.getHost() == null) {
+                tikTokRoomInfo.setHost(hostUser);
+            }
+            tikTokRoomInfo.setLanguage(language);
+        });
+    }
+
+    @SneakyThrows
+    public MappingResult handleMemberMessage(byte[] msg, String name, TikTokMapperHelper helper) {
+        var message = WebcastMemberMessage.parseFrom(msg);
+
+        var event = switch (message.getAction()) {
+            case JOINED -> new TikTokJoinEvent(message);
+            case SUBSCRIBED -> new TikTokSubscribeEvent(message);
+            default -> new TikTokUnhandledMemberEvent(message);
+        };
+
+        var roomInfoEvent = this.handleRoomInfo(tikTokRoomInfo ->
+        {
+            tikTokRoomInfo.setViewersCount(message.getMemberCount());
+        });
+        return MappingResult.of(message, List.of(event, roomInfoEvent));
+    }
+
+    @SneakyThrows
+    public MappingResult handleLike(byte[] msg, String name, TikTokMapperHelper helper) {
+        var message = WebcastLikeMessage.parseFrom(msg);
+        var event = new TikTokLikeEvent(message);
+        var roomInfoEvent = this.handleRoomInfo(tikTokRoomInfo ->
+        {
+            tikTokRoomInfo.setLikesCount(event.getTotalLikes());
+        });
+        return MappingResult.of(message, List.of(event, roomInfoEvent));
+    }
+}

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.mappers.handlers;
+
+import io.github.jwdeveloper.tiktok.TikTokRoomInfo;
+import io.github.jwdeveloper.tiktok.data.events.TikTokUnhandledSocialEvent;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.social.TikTokFollowEvent;
+import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
+import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
+import io.github.jwdeveloper.tiktok.data.events.social.TikTokShareEvent;
+import io.github.jwdeveloper.tiktok.data.models.Text;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastSocialMessage;
+import io.github.jwdeveloper.tiktok.models.SocialTypes;
+import lombok.SneakyThrows;
+import java.util.regex.Pattern;
+
+public class TikTokSocialMediaEventHandler
+{
+    private final TikTokRoomInfo roomInfo;
+    private final Pattern socialMediaPattern = Pattern.compile("pm_mt_guidance_viewer_([0-9]+)_share");
+
+    public TikTokSocialMediaEventHandler(TikTokRoomInfo roomInfo) {
+        this.roomInfo = roomInfo;
+    }
+
+    @SneakyThrows
+    public TikTokEvent handle(byte[] msg)
+    {
+        var message = WebcastSocialMessage.parseFrom(msg);
+
+        var socialType = Text.map(message.getCommon().getDisplayText()).getKey();
+        var matcher = socialMediaPattern.matcher(socialType);
+
+        if (matcher.find()) {
+            var value = matcher.group(1);
+            var number = Integer.parseInt(value);
+            return new TikTokShareEvent(message, number);
+        }
+
+        return switch (socialType) {
+            case SocialTypes.LikeType -> new TikTokLikeEvent(message, roomInfo.getLikesCount());
+            case SocialTypes.FollowType -> new TikTokFollowEvent(message);
+            case SocialTypes.ShareType -> new TikTokShareEvent(message);
+            case SocialTypes.JoinType -> new TikTokJoinEvent(message, roomInfo.getViewersCount());
+            default -> new TikTokUnhandledSocialEvent(message);
+        };
+    }
+
+
+}

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

@@ -24,11 +24,9 @@ package io.github.jwdeveloper.tiktok.websocket;
 
 
 import io.github.jwdeveloper.tiktok.ClientSettings;
-import io.github.jwdeveloper.tiktok.Constants;
-import io.github.jwdeveloper.tiktok.TikTokLiveClient;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
-import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandler;
 import io.github.jwdeveloper.tiktok.http.HttpUtils;
 import io.github.jwdeveloper.tiktok.http.TikTokCookieJar;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
@@ -41,24 +39,22 @@ import java.util.TreeMap;
 import java.util.logging.Logger;
 
 public class TikTokWebSocketClient implements SocketClient {
-    private final Logger logger;
     private final ClientSettings clientSettings;
     private final TikTokCookieJar tikTokCookieJar;
-    private final TikTokMessageHandlerRegistration webResponseHandler;
+    private final TikTokMessageHandler messageHandler;
     private final TikTokEventObserver tikTokEventHandler;
     private WebSocketClient webSocketClient;
     private TikTokWebSocketPingingTask pingingTask;
     private boolean isConnected;
 
-    public TikTokWebSocketClient(Logger logger,
+    public TikTokWebSocketClient(
                                  TikTokCookieJar tikTokCookieJar,
                                  ClientSettings clientSettings,
-                                 TikTokMessageHandlerRegistration webResponseHandler,
+                                 TikTokMessageHandler messageHandler,
                                  TikTokEventObserver tikTokEventHandler) {
-        this.logger = logger;
         this.tikTokCookieJar = tikTokCookieJar;
         this.clientSettings = clientSettings;
-        this.webResponseHandler = webResponseHandler;
+        this.messageHandler = messageHandler;
         this.tikTokEventHandler = tikTokEventHandler;
         isConnected = false;
     }
@@ -74,10 +70,7 @@ public class TikTokWebSocketClient implements SocketClient {
         }
 
         try {
-            if (clientSettings.isHandleExistingEvents()) {
-                logger.info("Handling existing events");
-                webResponseHandler.handle(tikTokLiveClient, webcastResponse);
-            }
+            messageHandler.handle(tikTokLiveClient, webcastResponse);
             var url = getWebSocketUrl(webcastResponse);
             webSocketClient = startWebSocket(url, tikTokLiveClient);
             webSocketClient.connect();
@@ -85,7 +78,8 @@ public class TikTokWebSocketClient implements SocketClient {
             pingingTask = new TikTokWebSocketPingingTask();
             pingingTask.run(webSocketClient);
             isConnected = true;
-        } catch (Exception e) {
+        } catch (Exception e)
+        {
             isConnected = false;
             throw new TikTokLiveException("Failed to connect to the websocket", e);
         }
@@ -109,7 +103,7 @@ public class TikTokWebSocketClient implements SocketClient {
         return new TikTokWebSocketListener(url,
                 headers,
                 3000,
-                webResponseHandler,
+                messageHandler,
                 tikTokEventHandler,
                 liveClient);
     }

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

@@ -28,7 +28,7 @@ import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokProtocolBufferException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
-import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandlerRegistration;
+import io.github.jwdeveloper.tiktok.handlers.TikTokMessageHandler;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastPushFrame;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
@@ -44,33 +44,22 @@ import java.util.Optional;
 
 public class TikTokWebSocketListener extends WebSocketClient {
 
-    private final TikTokMessageHandlerRegistration webResponseHandler;
+    private final TikTokMessageHandler messageHandler;
     private final TikTokEventObserver tikTokEventHandler;
     private final LiveClient tikTokLiveClient;
 
     public TikTokWebSocketListener(URI serverUri,
                                    Map<String, String> httpHeaders,
                                    int connectTimeout,
-                                   TikTokMessageHandlerRegistration webResponseHandler,
+                                   TikTokMessageHandler messageHandler,
                                    TikTokEventObserver tikTokEventHandler,
                                    LiveClient tikTokLiveClient) {
         super(serverUri, new Draft_6455(), httpHeaders,connectTimeout);
-        this.webResponseHandler = webResponseHandler;
+        this.messageHandler = messageHandler;
         this.tikTokEventHandler = tikTokEventHandler;
         this.tikTokLiveClient = tikTokLiveClient;
     }
 
-
-    @Override
-    public void onOpen(ServerHandshake serverHandshake) {
-        tikTokEventHandler.publish(tikTokLiveClient,new TikTokConnectedEvent());
-        if(isNotClosing())
-        {
-            sendPing();
-        }
-    }
-
-
     @Override
     public void onMessage(ByteBuffer bytes)
     {
@@ -85,6 +74,19 @@ public class TikTokWebSocketListener extends WebSocketClient {
         }
     }
 
+
+    @Override
+    public void onOpen(ServerHandshake serverHandshake) {
+        tikTokEventHandler.publish(tikTokLiveClient,new TikTokConnectedEvent());
+        if(isNotClosing())
+        {
+            sendPing();
+        }
+    }
+
+
+
+
     @Override
     public void onClose(int i, String s, boolean b) {
         tikTokEventHandler.publish(tikTokLiveClient,new TikTokDisconnectedEvent());
@@ -114,7 +116,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
            // sendAckId(webResponse.getFetchInterval());
         }
 
-        webResponseHandler.handle(tikTokLiveClient, webResponse);
+        messageHandler.handle(tikTokLiveClient, webResponse);
     }
 
     private Optional<WebcastPushFrame> getWebcastWebsocketMessage(byte[] buffer) {

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

@@ -46,6 +46,7 @@ public class TikTokGiftManagerTest {
         var gifts = giftManager.getGifts();
         var optional = gifts.stream().filter(r -> r == fakeGift).findFirst();
         Assertions.assertTrue(optional.isPresent());
+//        Assertions.assertNotNull(optional.get().name());
     }
 
     @Test
@@ -68,4 +69,7 @@ public class TikTokGiftManagerTest {
     }
 
 
+
+
+
 }

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

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.handlers.events;
+
+import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
+import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
+import io.github.jwdeveloper.tiktok.data.models.Picture;
+import io.github.jwdeveloper.tiktok.data.models.gifts.GiftSendType;
+import io.github.jwdeveloper.tiktok.gifts.TikTokGiftManager;
+import io.github.jwdeveloper.tiktok.mappers.handlers.TikTokGiftEventHandler;
+import io.github.jwdeveloper.tiktok.messages.data.GiftStruct;
+import io.github.jwdeveloper.tiktok.messages.data.Image;
+import io.github.jwdeveloper.tiktok.messages.data.User;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+import java.util.logging.Logger;
+
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class TikTokGiftEventHandlerTest {
+
+    public static TikTokGiftEventHandler handler;
+
+
+    @BeforeAll
+    public void before() {
+        var manager = new TikTokGiftManager(Logger.getLogger("x"));
+        manager.registerGift(123, "example", 123, new Picture("image.webp"));
+        handler = new TikTokGiftEventHandler(manager);
+    }
+
+    @Test
+    void shouldHandleGifts() {
+        var message = getGiftMessage("example-new-name", 123, "image-new.png", 0, 1,false);
+        var result = handler.handleGift(message);
+
+        Assertions.assertEquals(2, result.size());
+
+        var event = (TikTokGiftEvent) result.get(0);
+        var gift = event.getGift();
+        Assertions.assertEquals("image-new.png",gift.getPicture().getLink());
+        Assertions.assertEquals(123,gift.getId());
+    }
+
+    @Test
+    void shouldHandleStrakableGift() {
+        var message = getGiftMessage("example-new-name", 123, "image-new.png", 0, 1,true);
+        var result = handler.handleGift(message);
+
+        Assertions.assertEquals(1, result.size());
+
+        var event = (TikTokGiftEvent) result.get(0);
+        var gift = event.getGift();
+        Assertions.assertEquals("image-new.png",gift.getPicture().getLink());
+        Assertions.assertEquals(123,gift.getId());
+    }
+
+    @Test
+    void shouldHandleStrike()
+    {
+        var message1 = getGiftMessage("example-new-name", 123, "image-new.png", 1, 1,true);
+        var message2 = getGiftMessage("example-new-name", 123, "image-new.png", 2, 1,true);
+        var message3 = getGiftMessage("example-new-name", 123, "image-new.png", 0, 1,true);
+
+        var result1 = handler.handleGift(message1);
+        var result2 = handler.handleGift(message2);
+        var result3 = handler.handleGift(message3);
+
+        var event1 = (TikTokGiftComboEvent) result1.get(0);
+        var event2 = (TikTokGiftComboEvent) result2.get(0);
+
+        Assertions.assertEquals(2, result3.size());
+        var event3 = (TikTokGiftComboEvent) result3.get(0);
+
+        Assertions.assertEquals(GiftSendType.Begin,event1.getComboState());
+        Assertions.assertEquals(GiftSendType.Active,event2.getComboState());
+        Assertions.assertEquals(GiftSendType.Finished,event3.getComboState());
+    }
+
+
+    public WebcastGiftMessage getGiftMessage(String giftName,
+                                             int giftId,
+                                             String giftImage,
+                                             int sendType,
+                                             int userId,
+                                             boolean streakable) {
+        var builder = WebcastGiftMessage.newBuilder();
+        var giftBuilder = GiftStruct.newBuilder();
+        var userBuilder = User.newBuilder();
+
+
+        giftBuilder.setId(giftId);
+        giftBuilder.setName(giftName);
+        giftBuilder.setImage(Image.newBuilder().addUrlList(giftImage).build());
+        giftBuilder.setType(streakable?1:0);
+        userBuilder.setId(userId);
+
+        builder.setGiftId(giftId);
+        builder.setUser(userBuilder);
+        builder.setSendType(sendType);
+        builder.setGift(giftBuilder);
+        return builder.build();
+    }
+
+
+
+}

Client/src/test/java/io/github/jwdeveloper/tiktok/http/TikTokApiServiceTest.java

@@ -84,23 +84,8 @@ public class TikTokApiServiceTest
         verify(tiktokHttpClient, times(1)).setSessionId("validSessionId");
     }
 
-    @Test
-    void sendMessage_EmptySessionId_ThrowsException() {
-        assertThrows(TikTokLiveException.class, () -> {
-            tikTokApiService.sendMessage("some message", "");
-        });
-    }
 
-    @Test
-    void sendMessage_NullRoomId_ThrowsException() {
-        when(clientSettings.getClientParameters()).thenReturn(new HashMap<>());
-
-        assertThrows(TikTokLiveException.class, () -> {
-            tikTokApiService.sendMessage("some message", "someSessionId");
-        });
-    }
-
-    @Test
+   // @Test
     void fetchRoomId_ValidResponse_ReturnsRoomId() throws Exception {
         String expectedRoomId = "123456";
         String htmlResponse = "room_id=" + expectedRoomId ;
@@ -112,7 +97,7 @@ public class TikTokApiServiceTest
         verify(clientSettings.getClientParameters()).put("room_id", expectedRoomId);
     }
 
-    @Test
+   // @Test
     void fetchRoomId_ExceptionThrown_ThrowsTikTokLiveRequestException() throws Exception {
         when(tiktokHttpClient.getLivestreamPage(anyString())).thenThrow(new Exception("some exception"));
 
@@ -121,14 +106,14 @@ public class TikTokApiServiceTest
         });
     }
 
-    @Test
+    //@Test
     void fetchRoomInfo_ValidResponse_ReturnsLiveRoomMeta() throws Exception {
         HashMap<String, Object> clientParameters = new HashMap<>();
         var mockResponse = new JsonObject();  // Assume JsonObject is from the Gson library
         var expectedLiveRoomMeta = new LiveRoomMeta();  // Assume LiveRoomMeta is a simple POJO
 
         when(clientSettings.getClientParameters()).thenReturn(clientParameters);
-        when(tiktokHttpClient.getJObjectFromWebcastAPI(anyString(), any())).thenReturn(mockResponse);
+        when(tiktokHttpClient.getJsonFromWebcastApi(anyString(), any())).thenReturn(mockResponse);
         when(new LiveRoomMetaMapper().map(mockResponse)).thenReturn(expectedLiveRoomMeta);  // Assuming LiveRoomMetaMapper is a simple mapper class
 
         LiveRoomMeta liveRoomMeta = tikTokApiService.fetchRoomInfo();
@@ -136,9 +121,9 @@ public class TikTokApiServiceTest
         assertEquals(expectedLiveRoomMeta, liveRoomMeta);
     }
 
-    @Test
+//    @Test
     void fetchRoomInfo_ExceptionThrown_ThrowsTikTokLiveRequestException() throws Exception {
-        when(tiktokHttpClient.getJObjectFromWebcastAPI(anyString(), any())).thenThrow(new Exception("some exception"));
+        when(tiktokHttpClient.getJsonFromWebcastApi(anyString(), any())).thenThrow(new Exception("some exception"));
 
         assertThrows(TikTokLiveRequestException.class, () -> {
             tikTokApiService.fetchRoomInfo();

Client/src/test/java/io/github/jwdeveloper/tiktok/http/TikTokLiveOnlineCheckerTest.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.http;
+
+import io.github.jwdeveloper.tiktok.TikTokLive;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Random;
+
+public class TikTokLiveOnlineCheckerTest {
+
+    public boolean enableTests = false;
+
+    @Test
+    public void shouldTestOnline() {
+
+        if(!enableTests)
+        {
+            return;
+        }
+
+        var TARGET_USER = "bangbetmenygy";
+        var sut = new TikTokDataChecker();
+        var result = sut.isOnline(TARGET_USER);
+
+        Assertions.assertTrue(result);
+    }
+
+    @Test
+    public void shouldBeOffline() {
+
+        var TARGET_USER = "karacomparetto";
+        var sut = new TikTokDataChecker();
+        var result = sut.isOnline(TARGET_USER);
+
+        Assertions.assertFalse(result);
+    }
+
+    @Test
+    public void shouldBeValid() throws InterruptedException {
+
+        var TARGET_USER = "dostawcavideo";
+        var sut = new TikTokDataChecker();
+        var result = sut.isHostNameValid(TARGET_USER);
+
+
+        TikTokLive.newClient("asdasd")
+                        .onWebsocketResponse((liveClient, event) ->
+                        {
+                            for(var message : event.getResponse().getMessagesList())
+                            {
+                                if(message.getMethod().equals("WebcastGiftMessage"))
+                                {
+                                    try
+                                    {
+                                        var bytes = message.getMethodBytes();
+                                        var rawMessage = WebcastGiftMessage.parseFrom(bytes);
+                                        var giftName =rawMessage.getGift().getName();
+                                    }
+                                    catch (Exception e)
+                                    {
+                                        e.printStackTrace();
+                                    }
+
+                                }
+                            }
+                        });
+
+        Assertions.assertTrue(result);
+    }
+
+    @Test
+    public void shouldNotBeValid() {
+        var TARGET_USER = "dqagdagda , asdaaasd";
+        var sut = new TikTokDataChecker();
+        var result = sut.isHostNameValid(TARGET_USER);
+
+        Assertions.assertFalse(result);
+    }
+
+}

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

@@ -22,12 +22,11 @@
  */
 package io.github.jwdeveloper.tiktok.listener;
 
-import io.github.jwdeveloper.tiktok.annotations.TikTokEventHandler;
+import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
 import io.github.jwdeveloper.tiktok.data.events.social.TikTokJoinEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
-import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -42,12 +41,12 @@ import static org.mockito.Mockito.verify;
 
 class TikTokListenersManagerTest {
 
-    private TikTokEventObserver eventObserver;
+    private io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver eventObserver;
     private TikTokListenersManager tikTokListenersManager;
 
     @BeforeEach
     void setUp() {
-        eventObserver = Mockito.mock(TikTokEventObserver.class);
+        eventObserver = Mockito.mock(io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver.class);
         List<TikTokEventListener> listeners = new ArrayList<>();
         tikTokListenersManager = new TikTokListenersManager(listeners, eventObserver);
     }
@@ -93,19 +92,19 @@ class TikTokListenersManagerTest {
 
     public static class TikTokEventListenerTest implements TikTokEventListener
     {
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onJoin(LiveClient client, TikTokJoinEvent joinEvent)
         {
 
         }
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onGift(LiveClient client, TikTokGiftEvent giftMessageEvent)
         {
 
         }
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onEvent(LiveClient client, TikTokEvent event)
         {
 

Examples/pom.xml

@@ -41,7 +41,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>0.0.25-Release</version>
+        <version>1.0.9-Release</version>
     </parent>
 
     <modelVersion>4.0.0</modelVersion>

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.tiktok.data.models.Picture;
+import io.github.jwdeveloper.tiktok.live.GiftManager;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
+
+public class CustomGiftExample {
+    /**
+     * If you can't find your wanted Gift inside Gift enum register it manually
+     */
+
+
+    public static void main(String[] args) {
+        LiveClient client = TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
+                .onConnected((liveClient, event) ->
+                {
+                    liveClient.disconnect();
+                })
+                .onWebsocketResponse((liveClient, event) ->
+                {
+                    var packets =event.getResponse().getMessagesList();
+                    for(var packet : packets)
+                    {
+                        var name = packet.getMethod();
+                        var data = packet.getPayload();
+                        if(name.equals("WebcastGiftMessage"))
+                        {
+                         //   var message = WebcastGiftMessage.parseFrom(data);
+
+                        }
+                    }
+                })
+                .onGift((liveClient, event) ->
+                {
+                    liveClient.getLogger().info(event.getGift().getName());
+                }).build();
+
+        GiftManager giftManager = client.getGiftManager();
+
+        //If you can't find your wanted Gift inside Gift enum register it manually
+        giftManager.registerGift(123, "my custom gift", 69, new Picture("https://as2.ftcdn.net/v2/jpg/03/03/62/45/1000_F_303624505_u0bFT1Rnoj8CMUSs8wMCwoKlnWlh5Jiq.jpg"));
+
+
+        //You can also override existing gift, for example Rose has Id 5655
+        //We can make our custom gift appear in the event instead of rose
+        giftManager.registerGift(5655, "custom-rose", 999, new Picture("https://as2.ftcdn.net/v2/jpg/03/03/62/45/1000_F_303624505_u0bFT1Rnoj8CMUSs8wMCwoKlnWlh5Jiq.jpg"));
+
+        client.connect();
+    }
+}

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

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.mappers.data.MappingResult;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastChatMessage;
+
+public class CustomMappingExample {
+
+    public static void main(String[] args) {
+        TikTokLive.newClient("saszareznikow")
+                .onMapping(mapper ->
+                {
+                    mapper.forMessage(WebcastChatMessage.class)
+                            .onBeforeMapping((inputBytes, messageName, mapperHelper) ->
+                            {
+                                System.out.println("===============================");
+                                System.out.println("OnBefore mapping: " + messageName);
+                                return inputBytes;
+                            })
+                            .onMapping((inputBytes, messageName, mapperHelper) ->
+                            {
+                                System.out.println("onMapping mapping: " + messageName);
+                                var message = mapperHelper.bytesToWebcastObject(inputBytes, WebcastChatMessage.class);
+                                var language = message.getContentLanguage();
+                                var userName = message.getUser().getNickname();
+                                var content = message.getContent();
+                                var event = new CustomChatEvent(language, userName, content);
+                                return MappingResult.of(message, event);
+                            })
+                            .onAfterMapping(mappingResult ->
+                            {
+                                var source = mappingResult.getSource();
+                                var events = mappingResult.getEvents();
+                                System.out.println("onAfter mapping, " + source.getClass().getSimpleName() + " was mapped to " + events.size() + " events");
+                                return events;
+                            });
+
+                    /*
+                      There might be cast that we don't have Webcast class for incoming message from TikTok
+                      `mapperHelper.bytesToProtoBufferStructure` but you can still investigate message structure
+                       by using helper methods
+                     */
+                    mapper.forMessage("WebcastMemberMessage")
+                            .onBeforeMapping((inputBytes, messageName, mapperHelper) ->
+                            {
+                                if (mapperHelper.isMessageHasProtoClass(messageName)) {
+                                    var messageObject = mapperHelper.bytesToWebcastObject(inputBytes, messageName);
+                                    //    System.out.println(mapperHelper.toJson(messageObject));
+                                } else {
+                                    var structure = mapperHelper.bytesToProtoBufferStructure(inputBytes);
+                                    //     System.out.println(structure.toJson());
+                                }
+                                return inputBytes;
+                            });
+                })
+                .onError((liveClient, event) ->
+                {
+                    event.getException().printStackTrace();
+                })
+                .buildAndConnect();
+
+    }
+
+    public static class CustomChatEvent extends TikTokEvent {
+        private final String langauge;
+        private final String userName;
+        private final String message;
+
+        public CustomChatEvent(String language, String userName, String message) {
+            this.langauge = language;
+            this.userName = userName;
+            this.message = message;
+        }
+
+        public String getLangauge() {
+            return langauge;
+        }
+
+        public String getUserName() {
+            return userName;
+        }
+
+        public String getMessage() {
+            return message;
+        }
+
+        @Override
+        public String toString() {
+            return "CustomChatEvent{" +
+                    "language='" + langauge + '\'' +
+                    ", userName='" + userName + '\'' +
+                    ", message='" + message + '\'' +
+                    '}';
+        }
+
+    }
+}

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

@@ -22,7 +22,7 @@
  */
 package io.github.jwdeveloper.tiktok;
 
-import io.github.jwdeveloper.tiktok.annotations.TikTokEventHandler;
+import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.data.events.TikTokCommentEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
@@ -65,24 +65,24 @@ public class ListenerExample
 
     public static class CustomListener implements TikTokEventListener {
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onLike(LiveClient liveClient, TikTokLikeEvent event) {
             System.out.println(event.toString());
         }
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onError(LiveClient liveClient, TikTokErrorEvent event) {
           //  event.getException().printStackTrace();
         }
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onComment(LiveClient liveClient, TikTokCommentEvent event) {
             var userName = event.getUser().getName();
             var text = event.getText();
             liveClient.getLogger().info(userName + ": " + text);
         }
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onGift(LiveClient liveClient, TikTokGiftEvent event) {
             var message = switch (event.getGift()) {
                 case ROSE -> "Thanks :)";
@@ -95,7 +95,7 @@ public class ListenerExample
             liveClient.getLogger().info(message);
         }
 
-        @TikTokEventHandler
+        @TikTokEventObserver
         public void onAnyEvent(LiveClient liveClient, TikTokEvent event) {
             liveClient.getLogger().info(event.getClass().getSimpleName());
         }

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

@@ -22,19 +22,67 @@
  */
 package io.github.jwdeveloper.tiktok;
 
+import io.github.jwdeveloper.tiktok.data.events.TikTokSubNotifyEvent;
+import io.github.jwdeveloper.tiktok.data.events.TikTokSubscribeEvent;
+import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveOfflineHostException;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
 import io.github.jwdeveloper.tiktok.utils.ConsoleColors;
+import io.github.jwdeveloper.tiktok.utils.JsonUtil;
 
 import java.io.IOException;
 import java.time.Duration;
+import java.util.HashMap;
 import java.util.logging.Level;
 
-public class SimpleExample
-{
-    public static String TIKTOK_HOSTNAME = "szwagierkaqueen";
+public class SimpleExample {
+    public static String TIKTOK_HOSTNAME = "bangbetmenygy";
+
     public static void main(String[] args) throws IOException {
 
         showLogo();
         // set tiktok username
+
+
+
+
+        /*
+        //Optional checking if host name is correct
+        if(TikTokLive.isHostNameValid(TIKTOK_HOSTNAME))
+        {
+            System.out.println("user name exists!");
+        }
+         */
+
+        // Optional checking if live is online
+        if (TikTokLive.isLiveOnline(TIKTOK_HOSTNAME)) {
+            System.out.println("Live is online!");
+        }
+
+
+        TikTokLive.newClient("test")
+                .onWebsocketResponse((liveClient, event) ->
+                {
+                    var response = event.getResponse();
+                    for (var message : response.getMessagesList()) {
+                        var name = message.getMethod();
+                        var binaryData = message.getPayload();
+                        System.out.println("Event name: " + name);
+                        if (name.equals("WebcastGiftEvent")) {
+                            try {
+                                WebcastGiftMessage giftMessage = WebcastGiftMessage.parseFrom(binaryData);
+                                var giftName = giftMessage.getGift().getName();
+                                var giftId = giftMessage.getGiftId();
+                                var userName = giftMessage.getUser().getNickname();
+                                System.out.println("Gift: "+giftName+" id: "+giftId+" from user: "+userName);
+                            } catch (Exception e) {
+                                throw new RuntimeException("Mapping error", e);
+                            }
+                        }
+                    }
+                }).buildAndConnect();
+
+
         TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
                 .configure(clientSettings ->
                 {
@@ -43,7 +91,6 @@ public class SimpleExample
                     clientSettings.setTimeout(Duration.ofSeconds(2)); // Connection timeout
                     clientSettings.setLogLevel(Level.ALL); // Log level
                     clientSettings.setPrintToConsole(true); // Printing all logs to console even if log level is Level.OFF
-                    clientSettings.setHandleExistingEvents(true); // Invokes all TikTok events that had occurred before connection
                     clientSettings.setRetryOnConnectionFailure(true); // Reconnecting if TikTok user is offline
                     clientSettings.setRetryConnectionTimeout(Duration.ofSeconds(1)); // Timeout before next reconnection
 
@@ -58,18 +105,42 @@ public class SimpleExample
 
                     //clientSettings.setRoomId("XXXXXXXXXXXXXXXXX");
                 })
+                .onConnected((liveClient, event) ->
+                {
+                    for (var gift : liveClient.getGiftManager().getGifts()) {
+                        gift.getPicture().downloadImageAsync().thenAccept(image ->
+                        {
+
+                        });
+                    }
+                })
+                .onWebsocketMessage((liveClient, event) ->
+                {
+
+
+                    var tiktokLiveEvent = event.getEvent();
+                    if (tiktokLiveEvent instanceof TikTokSubNotifyEvent e) {
+                        System.out.println("it was subscrible event");
+                    }
+
+                })
+                .onWebsocketResponse((liveClient, event) ->
+                {
+                    event.getResponse();
+                })
                 .onGift((liveClient, event) ->
                 {
                     switch (event.getGift()) {
                         case ROSE -> print(ConsoleColors.RED, "Rose!");
                         case GG -> print(ConsoleColors.YELLOW, " GOOD GAME!");
-                        case TIKTOK -> print(ConsoleColors.CYAN,"Thanks for TikTok");
-                        default -> print(ConsoleColors.GREEN, "[Thanks for gift] ", ConsoleColors.YELLOW, event.getGift().getName(), "x", event.getCombo());
+                        case TIKTOK -> print(ConsoleColors.CYAN, "Thanks for TikTok");
+                        default ->
+                                print(ConsoleColors.GREEN, "[Thanks for gift] ", ConsoleColors.YELLOW, event.getGift().getName(), "x", event.getCombo());
                     }
                 })
                 .onGiftCombo((liveClient, event) ->
                 {
-                    print(ConsoleColors.RED,"GIFT COMBO",event.getGift().getName(),event.getCombo());
+                    print(ConsoleColors.RED, "GIFT COMBO", event.getGift().getName(), event.getCombo());
                 })
                 .onConnected((client, event) ->
                 {
@@ -77,7 +148,11 @@ public class SimpleExample
                 })
                 .onDisconnected((liveClient, event) ->
                 {
-                    print(ConsoleColors.RED,"[Disconnected]");
+                    print(ConsoleColors.RED, "[Disconnected]");
+                })
+                .onRoomInfo((liveClient, event) ->
+                {
+                    var info = event.getRoomInfo();
                 })
                 .onFollow((liveClient, event) ->
                 {
@@ -111,9 +186,8 @@ public class SimpleExample
         System.out.println(sb);
     }
 
-    private static void showLogo()
-    {
-        System.out.println(ConsoleColors.GREEN+"""
+    private static void showLogo() {
+        System.out.println(ConsoleColors.GREEN + """
                                 
                  _____ _ _    _____     _    _     _          \s
                 |_   _(_) | _|_   _|__ | | _| |   (_)_   _____\s

README.md

@@ -1,7 +1,6 @@
 <div align="center" >
 <a target="blank" >
 <img src="https://raw.githubusercontent.com/jwdeveloper/TikTokLiveJava/develop-1_0_0/Tools-ReadmeGenerator/src/main/resources/logo.svg" width="15%" >
-</img>
 </a>
 </div>
 <div align="center" >
@@ -12,26 +11,30 @@
 <div align="center" >
 <a href="https://jitpack.io/#jwdeveloper/TikTok-Live-Java" target="blank" >
 <img src="https://jitpack.io/v/jwdeveloper/TikTok-Live-Java.svg" width="20%" >
-</img>
 </a>
 
 
 <a href="https://discord.gg/e2XwPNTBBr" target="blank" >
 <img src="https://img.shields.io/badge/Discord-%235865F2.svg?style=for-the-badge&logo=discord&logoColor=white" >
-</img>
 </a>
 
 <a target="blank" >
 <img src="https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=openjdk&logoColor=white" >
-</img>
 </a>
 </div>
 </div>
 
 # Introduction
-A Java library inspired by [TikTokLive](https://github.com/isaackogan/TikTokLive) and [TikTokLiveSharp](https://github.com/sebheron/TikTokLiveSharp). Use it to receive live stream events such as comments and gifts in realtime from [TikTok LIVE](https://www.tiktok.com/live) by connecting to TikTok's internal WebCast push service. 
-The library includes a wrapper that connects to the WebCast service using just the username (`uniqueId`). This allows you to connect to your own live chat as well as the live chat of other streamers. 
-No credentials are required. Events such as [Members Joining](#member), [Gifts](#gift), [Subscriptions](#subscribe), [Viewers](#roomuser), [Follows](#social), [Shares](#social), [Questions](#questionnew), [Likes](#like) and [Battles](#linkmicbattle) can be tracked. 
+A Java library inspired by [TikTokLive](https://github.com/isaackogan/TikTokLive) and [TikTokLiveSharp](https://github.com/frankvHoof93/TikTokLiveSharp). Use it to receive live stream events such as comments and gifts in realtime from [TikTok LIVE](https://www.tiktok.com/live) by connecting to TikTok's internal WebCast push service.
+The library includes a wrapper that connects to the WebCast service using just the username (`uniqueId`). This allows you to connect to your own live chat as well as the live chat of other streamers.
+No credentials are required. Events such as [Members Joining](#member), [Gifts](#gift), [Subscriptions](#subscribe), [Viewers](#roomuser), [Follows](#social), [Shares](#social), [Questions](#questionnew), [Likes](#like) and [Battles](#linkmicbattle) can be tracked.
+
+# Contributors
+[Library documentation for contributors](https://github.com/jwdeveloper/TikTokLiveJava/wiki)
+
+<div align="center">
+  <a href="https://www.youtube.com/watch?v=eerWGgUKc6c" align="right" target="blank"><img src="https://img.youtube.com/vi/eerWGgUKc6c/hqdefault.jpg" alt="IMAGE ALT TEXT" width="38%" align="right"></a>
+</div>
 
 Join the support [discord](https://discord.gg/e2XwPNTBBr) and visit the `#java-support` channel for questions, contributions and ideas. Feel free to make pull requests with missing/new features, fixes, etc
 
@@ -51,8 +54,9 @@ Do you prefer other programming languages?
 
 ## Getting started
 
-1. Install the package via Maven
+1. Install the package
 
+Maven
 ```xml
    <repositories>
         <repository>
@@ -65,12 +69,27 @@ Do you prefer other programming languages?
          <dependency>
             <groupId>com.github.jwdeveloper.TikTok-Live-Java</groupId>
             <artifactId>Client</artifactId>
-            <version>NOT_FOUND</version>
+             <version>1.0.8-Release</version>
             <scope>compile</scope>
         </dependency>
    </dependencies>
 ```
 
+Gradle
+```gradle
+dependencyResolutionManagement {
+		repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+		repositories {
+			mavenCentral()
+			maven { url 'https://jitpack.io' }
+		}
+	}
+
+dependencies {
+	        implementation 'com.github.jwdeveloper.TikTok-Live-Java:Client:1.0.8-Release'
+	}
+```
+
 2. Create your first chat connection
 
 ```java
@@ -91,6 +110,13 @@ TikTokLive.newClient("bangbetmenygy")
         {
             System.out.println(event.getComboState()+ " " + event.getCombo() + " " + event.getGift().getName());
         })
+        .onRoomInfo((liveClient, event) ->
+        {
+            var roomInfo = event.getRoomInfo();
+            System.out.println("Room Id: "+roomInfo.getRoomId());
+            System.out.println("Likes: "+roomInfo.getLikesCount());
+            System.out.println("Viewers: "+roomInfo.getViewersCount());
+        })
         .onJoin((liveClient, event) ->
         {
             System.out.println(event.getUser().getProfileName() + "Hello on my stream! ");
@@ -118,7 +144,6 @@ TikTokLive.newClient("bangbetmenygy")
                     settings.setTimeout(Duration.ofSeconds(2)); // Connection timeout
                     settings.setLogLevel(Level.ALL); // Log level
                     settings.setPrintToConsole(true); // Printing all logs to console even if log level is Level.OFF
-                    settings.setHandleExistingEvents(true); // Invokes all TikTok events that had occurred before connection
                     settings.setRetryOnConnectionFailure(true); // Reconnecting if TikTok user is offline
                     settings.setRetryConnectionTimeout(Duration.ofSeconds(1)); // Timeout before next reconnection
 
@@ -140,36 +165,35 @@ TikTokLive.newClient("bangbetmenygy")
 
 
 
- **Control**:
+**Control**:
 
 - [onConnected](#onconnected-tiktokconnectedevent)
-- [onReconnecting](#onreconnecting-tiktokreconnectingevent)
 - [onDisconnected](#ondisconnected-tiktokdisconnectedevent)
+- [onReconnecting](#onreconnecting-tiktokreconnectingevent)
 - [onError](#onerror-tiktokerrorevent)
 
- **Message**:
+**Message**:
 
 - [onEvent](#onevent-tiktokevent)
-- [onShare](#onshare-tiktokshareevent)
-- [onLivePaused](#onlivepaused-tiktoklivepausedevent)
-- [onRoom](#onroom-tiktokroomevent)
-- [onGiftCombo](#ongiftcombo-tiktokgiftcomboevent)
-- [onJoin](#onjoin-tiktokjoinevent)
-- [onRoomUserInfo](#onroomuserinfo-tiktokroomuserinfoevent)
-- [onComment](#oncomment-tiktokcommentevent)
-- [onGift](#ongift-tiktokgiftevent)
-- [onLike](#onlike-tiktoklikeevent)
 - [onSubscribe](#onsubscribe-tiktoksubscribeevent)
 - [onQuestion](#onquestion-tiktokquestionevent)
-- [onEmote](#onemote-tiktokemoteevent)
-- [onLiveEnded](#onliveended-tiktokliveendedevent)
 - [onFollow](#onfollow-tiktokfollowevent)
-- [onUnhandledSocial](#onunhandledsocial-tiktokunhandledsocialevent)
+- [onLike](#onlike-tiktoklikeevent)
+- [onLiveEnded](#onliveended-tiktokliveendedevent)
+- [onRoomInfo](#onroominfo-tiktokroominfoevent)
+- [onShare](#onshare-tiktokshareevent)
+- [onGiftCombo](#ongiftcombo-tiktokgiftcomboevent)
+- [onEmote](#onemote-tiktokemoteevent)
+- [onGift](#ongift-tiktokgiftevent)
+- [onComment](#oncomment-tiktokcommentevent)
+- [onLivePaused](#onlivepaused-tiktoklivepausedevent)
+- [onLiveUnpaused](#onliveunpaused-tiktokliveunpausedevent)
+- [onJoin](#onjoin-tiktokjoinevent)
 
- **Debug**:
+**Debug**:
 
-- [onWebsocketResponse](#onwebsocketresponse-tiktokwebsocketresponseevent)
 - [onWebsocketUnhandledMessage](#onwebsocketunhandledmessage-tiktokwebsocketunhandledmessageevent)
+- [onWebsocketResponse](#onwebsocketresponse-tiktokwebsocketresponseevent)
 - [onWebsocketMessage](#onwebsocketmessage-tiktokwebsocketmessageevent)
 # Examples
 <br>
@@ -177,8 +201,8 @@ TikTokLive.newClient("bangbetmenygy")
 ## onConnected [TikTokConnectedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokConnectedEvent.java)
 
 
-  Triggered when the connection is successfully established.
- 
+Triggered when the connection is successfully established.
+
 
 ```java
 TikTokLive.newClient("host-name")
@@ -191,6 +215,26 @@ TikTokLive.newClient("host-name")
 
 
 
+<br>
+
+## onDisconnected [TikTokDisconnectedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokDisconnectedEvent.java)
+
+
+Triggered when the connection gets disconnected. In that case you can call connect() again to have a reconnect logic.
+Note that you should wait a little bit before attempting a reconnect to to avoid being rate-limited.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onDisconnected((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
 <br>
 
 ## onReconnecting [TikTokReconnectingEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokReconnectingEvent.java)
@@ -208,33 +252,13 @@ TikTokLive.newClient("host-name")
 
 
 
-<br>
-
-## onDisconnected [TikTokDisconnectedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokDisconnectedEvent.java)
-
-
-  Triggered when the connection gets disconnected. In that case you can call connect() again to have a reconnect logic.
-  Note that you should wait a little bit before attempting a reconnect to to avoid being rate-limited.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onDisconnected((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
 <br>
 
 ## onError [TikTokErrorEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokErrorEvent.java)
 
 
-  General error event. You should handle this.
- 
+General error event. You should handle this.
+
 
 ```java
 TikTokLive.newClient("host-name")
@@ -252,8 +276,8 @@ TikTokLive.newClient("host-name")
 ## onEvent [TikTokEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/common/TikTokEvent.java)
 
 
-  Base class for all events
- 
+Base class for all events
+
 
 ```java
 TikTokLive.newClient("host-name")
@@ -266,13 +290,125 @@ TikTokLive.newClient("host-name")
 
 
 
+<br>
+
+## onSubscribe [TikTokSubscribeEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokSubscribeEvent.java)
+
+
+Triggers when a user creates a subscription.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onSubscribe((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onQuestion [TikTokQuestionEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokQuestionEvent.java)
+
+
+Triggered every time someone asks a new question via the question feature.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onQuestion((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onFollow [TikTokFollowEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokFollowEvent.java)
+
+
+Triggers when a user follows the streamer. Based on social event.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onFollow((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onLike [TikTokLikeEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokLikeEvent.java)
+
+
+Triggered when a viewer sends likes to the streamer. For streams with many viewers, this event is not always triggered by TikTok.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onLike((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onLiveEnded [TikTokLiveEndedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokLiveEndedEvent.java)
+
+
+Triggered when the live stream gets terminated by the host. Will also trigger the TikTokDisconnectedEvent event.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onLiveEnded((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onRoomInfo [TikTokRoomInfoEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/room/TikTokRoomInfoEvent.java)
+
+
+
+```java
+TikTokLive.newClient("host-name")
+.onRoomInfo((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
 <br>
 
 ## onShare [TikTokShareEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokShareEvent.java)
 
 
-  Triggers when a user shares the stream. Based on social event.
- 
+Triggers when a user shares the stream. Based on social event.
+
 
 ```java
 TikTokLive.newClient("host-name")
@@ -285,6 +421,94 @@ TikTokLive.newClient("host-name")
 
 
 
+<br>
+
+## onGiftCombo [TikTokGiftComboEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/gift/TikTokGiftComboEvent.java)
+
+
+Triggered every time gift is sent
+
+@see GiftSendType it has 3 states
+
+  <p>Example when user sends gift with combo</p>
+  <p>>Combo: 1  -> comboState = GiftSendType.Begin</p>
+  <p>Combo: 4 -> comboState = GiftSendType.Active</p>
+  <p>Combo: 8 -> comboState = GiftSendType.Active</p>
+  <p>Combo: 12 -> comboState = GiftSendType.Finished</p>
+
+Remember if comboState is Finished both TikTokGiftComboEvent and TikTokGiftEvent event gets triggered
+
+
+```java
+TikTokLive.newClient("host-name")
+.onGiftCombo((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onEmote [TikTokEmoteEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokEmoteEvent.java)
+
+
+Triggered every time a subscriber sends an emote (sticker).
+
+
+```java
+TikTokLive.newClient("host-name")
+.onEmote((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onGift [TikTokGiftEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/gift/TikTokGiftEvent.java)
+
+
+Triggered when user sends gifts that has
+no combo (most of expensive gifts)
+or if combo has finished
+
+
+```java
+TikTokLive.newClient("host-name")
+.onGift((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
+<br>
+
+## onComment [TikTokCommentEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokCommentEvent.java)
+
+
+Triggered every time a new chat comment arrives.
+
+
+```java
+TikTokLive.newClient("host-name")
+.onComment((liveClient, event) ->
+{
+
+})
+.buildAndConnect();
+```
+
+
+
 <br>
 
 ## onLivePaused [TikTokLivePausedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokLivePausedEvent.java)
@@ -304,42 +528,13 @@ TikTokLive.newClient("host-name")
 
 <br>
 
-## onRoom [TikTokRoomEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/room/TikTokRoomEvent.java)
+## onLiveUnpaused [TikTokLiveUnpausedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokLiveUnpausedEvent.java)
 
 
 
 ```java
 TikTokLive.newClient("host-name")
-.onRoom((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onGiftCombo [TikTokGiftComboEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/gift/TikTokGiftComboEvent.java)
-
-
-  Triggered every time gift is sent
- 
-  @see GiftSendType it has 3 states
- 
-  <p>Example when user sends gift with combo</p>
-  <p>>Combo: 1  -> comboState = GiftSendType.Begin</p>
-  <p>Combo: 4 -> comboState = GiftSendType.Active</p>
-  <p>Combo: 8 -> comboState = GiftSendType.Active</p>
-  <p>Combo: 12 -> comboState = GiftSendType.Finsihed</p>
- 
-  Remember if comboState is Finsihed both TikTokGiftComboEvent and TikTokGiftEvent event gets triggered
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onGiftCombo((liveClient, event) ->
+.onLiveUnpaused((liveClient, event) ->
 {
 
 })
@@ -367,187 +562,15 @@ TikTokLive.newClient("host-name")
 
 <br>
 
-## onRoomUserInfo [TikTokRoomUserInfoEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/room/TikTokRoomUserInfoEvent.java)
+## onWebsocketUnhandledMessage [TikTokWebsocketUnhandledMessageEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/websocket/TikTokWebsocketUnhandledMessageEvent.java)
 
 
-      Only top 5 users in ranking has detailed data
-      rest has only ID
-     
-
-```java
-TikTokLive.newClient("host-name")
-.onRoomUserInfo((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onComment [TikTokCommentEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokCommentEvent.java)
-
-
-  Triggered every time a new chat comment arrives.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onComment((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onGift [TikTokGiftEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/gift/TikTokGiftEvent.java)
-
-
-  Triggered when user sends gifts that has
-   no combo (most of expensive gifts)
-   or if combo has finished
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onGift((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onLike [TikTokLikeEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokLikeEvent.java)
-
-
-  Triggered when a viewer sends likes to the streamer. For streams with many viewers, this event is not always triggered by TikTok.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onLike((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onSubscribe [TikTokSubscribeEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokSubscribeEvent.java)
-
-
-  Triggers when a user creates a subscription.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onSubscribe((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onQuestion [TikTokQuestionEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokQuestionEvent.java)
-
-
-Triggered every time someone asks a new question via the question feature.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onQuestion((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onEmote [TikTokEmoteEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokEmoteEvent.java)
-
-
-  Triggered every time a subscriber sends an emote (sticker).
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onEmote((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onLiveEnded [TikTokLiveEndedEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokLiveEndedEvent.java)
-
-
-  Triggered when the live stream gets terminated by the host. Will also trigger the TikTokDisconnectedEvent event.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onLiveEnded((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onFollow [TikTokFollowEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/social/TikTokFollowEvent.java)
-
-
-  Triggers when a user follows the streamer. Based on social event.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onFollow((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onUnhandledSocial [TikTokUnhandledSocialEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokUnhandledSocialEvent.java)
-
+Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
 
 
 ```java
 TikTokLive.newClient("host-name")
-.onUnhandledSocial((liveClient, event) ->
+.onWebsocketUnhandledMessage((liveClient, event) ->
 {
 
 })
@@ -564,30 +587,11 @@ TikTokLive.newClient("host-name")
 
 ```java
 TikTokLive.newClient("host-name")
-.onWebsocketResponse((liveClient, event) ->
-{
+        .onWebsocketResponse((liveClient, event) ->
+        {
 
-})
-.buildAndConnect();
-```
-
-
-
-<br>
-
-## onWebsocketUnhandledMessage [TikTokWebsocketUnhandledMessageEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/websocket/TikTokWebsocketUnhandledMessageEvent.java)
-
-
-  Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
- 
-
-```java
-TikTokLive.newClient("host-name")
-.onWebsocketUnhandledMessage((liveClient, event) ->
-{
-
-})
-.buildAndConnect();
+        })
+        .buildAndConnect();
 ```
 
 
@@ -597,16 +601,16 @@ TikTokLive.newClient("host-name")
 ## onWebsocketMessage [TikTokWebsocketMessageEvent](https://github.com/jwdeveloper/TikTokLiveJava/blob/master/API/src/main/java/io/github/jwdeveloper/tiktok/data/events/websocket/TikTokWebsocketMessageEvent.java)
 
 
-  Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
- 
+Triggered every time a protobuf encoded webcast message arrives. You can deserialize the binary object depending on the use case.
+
 
 ```java
 TikTokLive.newClient("host-name")
-.onWebsocketMessage((liveClient, event) ->
-{
+        .onWebsocketMessage((liveClient, event) ->
+        {
 
-})
-.buildAndConnect();
+        })
+        .buildAndConnect();
 ```
 
 
@@ -619,74 +623,74 @@ TikTokLive.newClient("host-name")
 
 ```java
 
-    /**
-     *
-     *  Listeners are an alternative way of handling events.
-     *  I would to suggest to use then when logic of handing event
-     *  is more complex
-     *
-     */
-    public static void main(String[] args) throws IOException {
+/**
+ *
+ *  Listeners are an alternative way of handling events.
+ *  I would to suggest to use then when logic of handing event
+ *  is more complex
+ *
+ */
+public static void main(String[] args) throws IOException {
         showLogo();
         CustomListener customListener = new CustomListener();
 
         TikTokLive.newClient(SimpleExample.TIKTOK_HOSTNAME)
-                .addListener(customListener)
-                .buildAndConnect();
+        .addListener(customListener)
+        .buildAndConnect();
         System.in.read();
+        }
+
+/**
+ *
+ *  Method in TikTokEventListener should meet 4 requirements to be detected
+ *         - must have @TikTokEventHandler annotation
+ *         - must have 2 parameters
+ *         - first parameter must be LiveClient
+ *         - second must be class that extending TikTokEvent
+ */
+
+public static class CustomListener implements TikTokEventListener {
+
+    @TikTokEventHandler
+    public void onLike(LiveClient liveClient, TikTokLikeEvent event) {
+        System.out.println(event.toString());
     }
 
-    /**
-     *
-     *  Method in TikTokEventListener should meet 4 requirements to be detected
-     *         - must have @TikTokEventHandler annotation
-     *         - must have 2 parameters
-     *         - first parameter must be LiveClient
-     *         - second must be class that extending TikTokEvent
-     */
-
-    public static class CustomListener implements TikTokEventListener {
-
-        @TikTokEventHandler
-        public void onLike(LiveClient liveClient, TikTokLikeEvent event) {
-            System.out.println(event.toString());
-        }
-
-        @TikTokEventHandler
-        public void onError(LiveClient liveClient, TikTokErrorEvent event) {
-          //  event.getException().printStackTrace();
-        }
-
-        @TikTokEventHandler
-        public void onComment(LiveClient liveClient, TikTokCommentEvent event) {
-            var userName = event.getUser().getName();
-            var text = event.getText();
-            liveClient.getLogger().info(userName + ": " + text);
-        }
-
-        @TikTokEventHandler
-        public void onGift(LiveClient liveClient, TikTokGiftEvent event) {
-            var message = switch (event.getGift()) {
-                case ROSE -> "Thanks :)";
-                case APPETIZERS -> ":OO";
-                case APRIL -> ":D";
-                case TIKTOK -> ":P";
-                case CAP -> ":F";
-                default -> ":I";
-            };
-            liveClient.getLogger().info(message);
-        }
-
-        @TikTokEventHandler
-        public void onAnyEvent(LiveClient liveClient, TikTokEvent event) {
-            liveClient.getLogger().info(event.getClass().getSimpleName());
-        }
-
+    @TikTokEventHandler
+    public void onError(LiveClient liveClient, TikTokErrorEvent event) {
+        //  event.getException().printStackTrace();
     }
 
-    // 
+    @TikTokEventHandler
+    public void onComment(LiveClient liveClient, TikTokCommentEvent event) {
+        var userName = event.getUser().getName();
+        var text = event.getText();
+        liveClient.getLogger().info(userName + ": " + text);
+    }
+
+    @TikTokEventHandler
+    public void onGift(LiveClient liveClient, TikTokGiftEvent event) {
+        var message = switch (event.getGift()) {
+            case ROSE -> "Thanks :)";
+            case APPETIZERS -> ":OO";
+            case APRIL -> ":D";
+            case TIKTOK -> ":P";
+            case CAP -> ":F";
+            default -> ":I";
+        };
+        liveClient.getLogger().info(message);
+    }
+
+    @TikTokEventHandler
+    public void onAnyEvent(LiveClient liveClient, TikTokEvent event) {
+        liveClient.getLogger().info(event.getClass().getSimpleName());
+    }
+
+}
+
+// 
 ```
 
 
 ## Contributing
-Your improvements are welcome! Feel free to open an <a href="https://github.com/jwdeveloper/TikTok-Live-Java/issues">issue</a> or <a href="https://github.com/jwdeveloper/TikTok-Live-Java/pulls">pull request</a>.
+Your improvements are welcome! Feel free to open an <a href="https://github.com/jwdeveloper/TikTok-Live-Java/issues">issue</a> or <a href="https://github.com/jwdeveloper/TikTok-Live-Java/pulls">pull request</a>.

Tools-EventsCollector/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>TikTokLiveJava</artifactId>
         <groupId>io.github.jwdeveloper.tiktok</groupId>
-        <version>0.0.25-Release</version>
+        <version>1.0.9-Release</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -29,6 +29,11 @@
             <artifactId>jdbi3-core</artifactId>
             <version>3.23.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.googlecode.protobuf-java-format</groupId>
+            <artifactId>protobuf-java-format</artifactId>
+            <version>1.4</version>
+        </dependency>
         <dependency>
             <groupId>org.jdbi</groupId>
             <artifactId>jdbi3-sqlobject</artifactId>

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/TikTokLiveTools.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.tools;
+
+import io.github.jwdeveloper.tiktok.tools.collector.client.TikTokDataCollectorBuilder;
+import io.github.jwdeveloper.tiktok.tools.collector.api.DataCollectorBuilder;
+import io.github.jwdeveloper.tiktok.tools.tester.TikTokDataTesterBuilder;
+import io.github.jwdeveloper.tiktok.tools.tester.api.DataTesterBuilder;
+
+public class TikTokLiveTools
+{
+    /**
+     *
+     * @param databaseName dataCollector use sql-lite database to store message
+     * if database not exits it creates new one
+     * @return
+     */
+    public static DataCollectorBuilder createCollector(String databaseName)
+    {
+        return new TikTokDataCollectorBuilder(databaseName);
+    }
+
+    /**
+     *
+     * @param databaseName dataTester will read messages for database
+     * before using dataTester, use dataCollector to create database
+     * if database not exits exception will be thrown
+     * @return
+     */
+    public static DataTesterBuilder createTester(String databaseName)
+    {
+        return new TikTokDataTesterBuilder(databaseName);
+    }
+
+    /**
+     *
+     *  Returns browser application that collects and display Events, Messages, WebcastResponses
+     *  in online web editor so it's easier to read and analyze data structures
+     * @return
+     */
+    public static void createWebViewer()
+    {
+
+    }
+}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/RunCollector.java

@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.tools.collector;
-
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastGiftMessage;
-import io.github.jwdeveloper.tiktok.tools.collector.client.TikTokMessageCollectorClient;
-
-import java.io.IOException;
-import java.sql.SQLException;
-
-public class RunCollector {
-
-    //https://protobuf-decoder.netlify.app/
-    //https://streamdps.com/tiktok-widgets/gifts/
-
-    //WebcastLinkMicBattleItemCard does streamer win battle?
-
-    public static void main(String[] args) throws SQLException, IOException {
-
-        TikTokMessageCollectorClient.create("giftsCollector")
-                .addUser("cbcgod")
-                // .addUser("mr_cios")
-               // .addUser("cbcgod")
-                //   .addUser("psychotropnazywo")
-                //  .addUser("accordionistka")
-                .addEventFilter(WebcastGiftMessage.class)
-                .addOnBuilder(liveClientBuilder ->
-                {
-                    liveClientBuilder.onGift((liveClient, event) ->
-                    {
-
-                    });
-
-                    liveClientBuilder.onGiftCombo((liveClient, event) ->
-                    {
-
-                    });
-
-                    liveClientBuilder.onGift((liveClient, event) ->
-                    {
-                       var sb = new StringBuilder();
-                        sb.append("GIFT User: " + event.getUser().getProfileName()+" ");
-                        sb.append("Name: " + event.getGift().name() + " ");
-                        sb.append("Combo: " + event.getCombo() + " ");
-                        System.out.println(sb.toString());
-                    });
-                    liveClientBuilder.onGiftCombo((liveClient, event) ->
-                    {
-                        var sb = new StringBuilder();
-                        sb.append("COMBO User: " + event.getUser().getProfileName()+" ");
-                        sb.append("Name: " + event.getGift().name() + " ");
-                        sb.append("Combo: " + event.getCombo() + " ");
-                        sb.append("Type: " + event.getComboState().name());
-                        System.out.println(sb.toString());
-                    });
-                })
-                .buildAndRun();
-
-        System.in.read();
-    }
-
-
-}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/api/DataCollector.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.tools.collector.api;
+
+public interface DataCollector {
+
+    void connect();
+
+
+    void disconnect();
+
+    void disconnect(boolean keepDatabase);
+}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/api/DataCollectorBuilder.java

@@ -20,41 +20,25 @@
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-package io.github.jwdeveloper.tiktok.utils;
+package io.github.jwdeveloper.tiktok.tools.collector.api;
 
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
+import io.github.jwdeveloper.tiktok.tools.db.TikTokDatabase;
 
-public class CancelationToken
-{
-    private boolean isCanceled =false;
+import java.util.function.Consumer;
 
-    public void cancel()
-    {
-        isCanceled =true;
-    }
+public interface DataCollectorBuilder extends DataFilters<DataCollectorBuilder> {
+    DataCollectorBuilder setOutputPath(String path);
+    DataCollectorBuilder setSessionTag(String sessionTimestamp);
 
-    public boolean isCancel()
-    {
+    DataCollectorBuilder setDatabase(TikTokDatabase database);
 
-        return isCanceled;
-    }
+    DataCollectorBuilder configureLiveClient(Consumer<LiveClientBuilder> consumer);
 
-    public void throwIfCancel()
-    {
-        if(!isCanceled)
-        {
-            return;
-        }
-        throw new TikTokLiveException("Token requested cancelation");
-    }
+    DataCollectorBuilder addUser(String user);
 
-    public boolean isNotCancel()
-    {
-        return !isCancel();
-    }
+    DataCollector buildAndRun();
+
+    DataCollector build();
 
-    public static CancelationToken create()
-    {
-        return new CancelationToken();
-    }
 }

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/api/DataFilters.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.tools.collector.api;
+
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+
+public interface DataFilters<T> {
+     T addMessageFilter(Class<? extends com.google.protobuf.GeneratedMessageV3> message);
+
+     T addMessageFilter(String message);
+
+     T addEventFilter(Class<? extends TikTokEvent> event);
+
+     T addEventFilter(String event);
+}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/api/TikTokDataCollectorModel.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.tools.collector.api;
+
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+
+@Data
+public class TikTokDataCollectorModel {
+    private List<String> users;
+    private String outputPath;
+    private String outputName;
+    private Set<String> eventsFilter;
+    private Set<String> messagesFilter;
+    private String sessionTag ="";
+    private Consumer<LiveClientBuilder> onConfigureLiveClient;
+}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/client/MessagesManager.java

@@ -37,14 +37,14 @@ import java.time.LocalDateTime;
 import java.util.*;
 import java.util.logging.Logger;
 
-public class MessageCollector {
+public class MessagesManager {
 
     @Getter
     Map<String, Queue<MessageData>> messages;
     String outputName;
 
     int limit = 20;
-    public MessageCollector(String outputName) {
+    public MessagesManager(String outputName) {
         this.messages = new TreeMap<>();
         this.outputName = outputName;
         load();

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/client/TikTokClientFactory.java

@@ -22,104 +22,16 @@
  */
 package io.github.jwdeveloper.tiktok.tools.collector.client;
 
-import io.github.jwdeveloper.tiktok.TikTokLive;
-import io.github.jwdeveloper.tiktok.TikTokLiveClientBuilder;
-import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageException;
-import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
-import io.github.jwdeveloper.tiktok.tools.collector.db.TikTokDatabase;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.ExceptionInfoModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokErrorModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokMessageModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokResponseModel;
-
-import java.util.Base64;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.Consumer;
+import io.github.jwdeveloper.tiktok.tools.db.TikTokDatabase;
 
 public class TikTokClientFactory {
-    private final MessageCollector messageCollector;
+    private final MessagesManager messageCollector;
     private final TikTokDatabase tikTokDatabase;
 
-    public TikTokClientFactory(MessageCollector messageCollector, TikTokDatabase tikTokDatabase) {
+    public TikTokClientFactory(MessagesManager messageCollector, TikTokDatabase tikTokDatabase) {
         this.messageCollector = messageCollector;
         this.tikTokDatabase = tikTokDatabase;
     }
 
-    public CompletableFuture<LiveClient> runClientAsync(String tiktokUser, List<Class<?>> filters, Consumer<LiveClientBuilder> onBuilder) {
-        var builder = TikTokLive.newClient(tiktokUser);
-        var msgFilter = filters.stream().map(Class::getSimpleName).toList();
-        onBuilder.accept(builder);
-        return builder.onConnected((liveClient, event) ->
-                {
-                    liveClient.getLogger().info("CONNECTED TO " + liveClient.getRoomInfo().getHostName());
-                })
-                .onWebsocketResponse((liveClient, event) ->
-                {
-                    var response = Base64.getEncoder().encodeToString(event.getResponse().toByteArray());
 
-                    var responseModel = new TikTokResponseModel();
-                    responseModel.setResponse(response);
-                    responseModel.setHostName(liveClient.getRoomInfo().getHostName());
-                    tikTokDatabase.insertResponse(responseModel);
-                    liveClient.getLogger().info("Response");
-                    for (var message : event.getResponse().getMessagesList())
-                    {
-                        if(msgFilter.size() > 0 && !msgFilter.contains(message.getMethod()))
-                        {
-                            continue;
-                        }
-                        messageCollector.addMessage(liveClient.getLogger(), liveClient.getRoomInfo().getHostName(), message);
-                    }
-                })
-                .onWebsocketMessage((liveClient, event) ->
-                {
-                    var eventName = event.getEvent().getClass().getSimpleName();
-
-                    /*
-                    if (msgFilter.size() != 0 && !msgFilter.contains(event.getEvent().getClass())) {
-                        return;
-                    }*/
-
-                    var messageBinary = Base64.getEncoder().encodeToString(event.getMessage().toByteArray());
-                    var model = new TikTokMessageModel();
-                    model.setType("messsage");
-                    model.setHostName(tiktokUser);
-                    model.setEventName(eventName);
-                    model.setMessage(messageBinary);
-
-                    //   tikTokDatabase.insertMessage(model);
-                   // liveClient.getLogger().info("EVENT: [" + tiktokUser + "] " + eventName);
-                })
-                .onError((liveClient, event) ->
-                {
-                    event.getException().printStackTrace();
-                    var exception = event.getException();
-                    var exceptionContent = ExceptionInfoModel.getStackTraceAsString(exception);
-                    var errorModel = new TikTokErrorModel();
-                    if (exception instanceof TikTokLiveMessageException ex) {
-                        errorModel.setHostName(tiktokUser);
-                        errorModel.setErrorName(ex.messageMethod());
-                        errorModel.setErrorType("error-message");
-                        errorModel.setExceptionContent(exceptionContent);
-                        errorModel.setMessage(ex.messageToBase64());
-                        errorModel.setResponse(ex.webcastResponseToBase64());
-                    } else {
-                        errorModel.setHostName(tiktokUser);
-                        errorModel.setErrorName(exception.getClass().getSimpleName());
-                        errorModel.setErrorType("error-system");
-                        errorModel.setExceptionContent(exceptionContent);
-                        errorModel.setMessage("");
-                        errorModel.setResponse("");
-                    }
-
-
-                    tikTokDatabase.insertError(errorModel);
-                    liveClient.getLogger().info("ERROR: " + errorModel.getErrorName());
-                    exception.printStackTrace();
-
-                })
-                .buildAndConnectAsync();
-    }
 }

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/client/TikTokDataCollector.java

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.tools.collector.client;
+
+import io.github.jwdeveloper.tiktok.TikTokLive;
+import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.data.events.http.TikTokHttpResponseEvent;
+import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketMessageEvent;
+import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketResponseEvent;
+import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveMessageException;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
+import io.github.jwdeveloper.tiktok.tools.collector.api.DataCollector;
+import io.github.jwdeveloper.tiktok.tools.collector.api.TikTokDataCollectorModel;
+import io.github.jwdeveloper.tiktok.tools.db.TikTokDatabase;
+import io.github.jwdeveloper.tiktok.tools.db.tables.ExceptionInfoModel;
+import io.github.jwdeveloper.tiktok.tools.db.tables.TikTokDataTable;
+import io.github.jwdeveloper.tiktok.tools.db.tables.TikTokErrorModel;
+import io.github.jwdeveloper.tiktok.utils.JsonUtil;
+
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+
+public class TikTokDataCollector implements DataCollector {
+    private final TikTokDataCollectorModel dataCollectorModel;
+    private final TikTokDatabase tikTokDatabase;
+    private final List<LiveClient> tiktokClients;
+
+    public TikTokDataCollector(TikTokDataCollectorModel dataCollectorModel, TikTokDatabase tikTokDatabase) {
+        this.dataCollectorModel = dataCollectorModel;
+        this.tikTokDatabase = tikTokDatabase;
+        this.tiktokClients = new ArrayList<>();
+    }
+
+    public void connect() {
+        try {
+            if (!tikTokDatabase.isConnected()) {
+                tikTokDatabase.connect();
+            }
+            for (var user : dataCollectorModel.getUsers()) {
+                var client = createLiveClient(user);
+                tiktokClients.add(client);
+                client.connectAsync();
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Unable to start tiktok connector", e);
+        }
+    }
+
+
+    public void disconnect() {
+        disconnect(false);
+    }
+
+    @Override
+    public void disconnect(boolean keepDatabase) {
+        try {
+            for (var client : tiktokClients) {
+                client.disconnect();
+            }
+            if (!keepDatabase) {
+                tikTokDatabase.close();
+            }
+
+        } catch (Exception e) {
+            throw new RuntimeException("Unable to stop tiktok connector", e);
+        }
+    }
+
+    public LiveClient createLiveClient(String tiktokUser) {
+        var builder = TikTokLive.newClient(tiktokUser);
+        builder.onConnected((liveClient, event) ->
+                {
+                    liveClient.getLogger().info("Connected to " + liveClient.getRoomInfo().getHostName());
+                })
+                .onDisconnected((liveClient, event) ->
+                {
+                    liveClient.getLogger().info("Disconnected " + liveClient.getRoomInfo().getHostName());
+                })
+                .onWebsocketResponse(this::handleResponseAndMessages)
+                .onWebsocketMessage(this::handleMappedEvent)
+                .onHttpResponse((liveClient, event) ->
+                {
+                    var data = createHttpResponseData(event, tiktokUser);
+                    tikTokDatabase.insertData(data);
+                })
+                .onError(this::handleError);
+        dataCollectorModel.getOnConfigureLiveClient().accept(builder);
+        return builder.build();
+    }
+
+    private void handleResponseAndMessages(LiveClient client, TikTokWebsocketResponseEvent event) {
+        var responseData = createResponseData(event.getResponse(), client.getRoomInfo().getHostName());
+        tikTokDatabase.insertData(responseData);
+
+        var filter = dataCollectorModel.getMessagesFilter();
+        for (var message : event.getResponse().getMessagesList()) {
+            if (filter.isEmpty()) {
+                var data = createMessageData(message, client.getRoomInfo().getHostName());
+                tikTokDatabase.insertData(data);
+                continue;
+            }
+            if (!filter.contains(message.getMethod())) {
+                continue;
+            }
+            var data = createMessageData(message, client.getRoomInfo().getHostName());
+            tikTokDatabase.insertData(data);
+        }
+    }
+
+    private void handleMappedEvent(LiveClient client, TikTokWebsocketMessageEvent messageEvent) {
+        var event = messageEvent.getEvent();
+        var eventName = event.getClass().getSimpleName();
+
+        var filter = dataCollectorModel.getEventsFilter();
+
+        if (filter.isEmpty()) {
+            var data = createEventData(event, client.getRoomInfo().getHostName());
+            tikTokDatabase.insertData(data);
+            return;
+        }
+
+        if (!filter.contains(eventName)) {
+            return;
+        }
+        var data = createEventData(event, client.getRoomInfo().getHostName());
+        tikTokDatabase.insertData(data);
+    }
+
+    private void handleError(LiveClient client, TikTokErrorEvent event) {
+        var exception = event.getException();
+        var userName = client.getRoomInfo().getHostName();
+        var exceptionContent = ExceptionInfoModel.getStackTraceAsString(exception);
+        var errorModel = new TikTokErrorModel();
+        if (exception instanceof TikTokLiveMessageException ex) {
+            errorModel.setHostName(userName);
+            errorModel.setErrorName(ex.messageMethod());
+            errorModel.setErrorType("error-message");
+            errorModel.setExceptionContent(exceptionContent);
+            errorModel.setMessage(ex.messageToBase64());
+            errorModel.setResponse(ex.webcastResponseToBase64());
+        } else {
+            errorModel.setHostName(userName);
+            errorModel.setErrorName(exception.getClass().getSimpleName());
+            errorModel.setErrorType("error-system");
+            errorModel.setExceptionContent(exceptionContent);
+            errorModel.setMessage("");
+            errorModel.setResponse("");
+        }
+
+
+        tikTokDatabase.insertError(errorModel);
+        client.getLogger().info("ERROR: " + errorModel.getErrorName());
+        exception.printStackTrace();
+    }
+
+    private TikTokDataTable createHttpResponseData(TikTokHttpResponseEvent response, String tiktokUser) {
+        var base64 = JsonUtil.toJson(response);
+        var data = new TikTokDataTable();
+        data.setSessionTag(dataCollectorModel.getSessionTag());
+        data.setTiktokUser(tiktokUser);
+        data.setDataType("response");
+        data.setDataTypeName("Http");
+        data.setContent(base64);
+        return data;
+    }
+
+
+    private TikTokDataTable createResponseData(WebcastResponse response, String tiktokUser) {
+        var base64 = Base64.getEncoder().encodeToString(response.toByteArray());
+        var data = new TikTokDataTable();
+        data.setSessionTag(dataCollectorModel.getSessionTag());
+        data.setTiktokUser(tiktokUser);
+        data.setDataType("response");
+        data.setDataTypeName("WebcastResponse");
+        data.setContent(base64);
+        return data;
+    }
+
+    private TikTokDataTable createMessageData(WebcastResponse.Message message, String tiktokUser) {
+        var base64 = Base64.getEncoder().encodeToString(message.getPayload().toByteArray());
+        var data = new TikTokDataTable();
+        data.setSessionTag(dataCollectorModel.getSessionTag());
+        data.setTiktokUser(tiktokUser);
+        data.setDataType("message");
+        data.setDataTypeName(message.getMethod());
+        data.setContent(base64);
+        return data;
+    }
+
+    private TikTokDataTable createEventData(TikTokEvent event, String tiktokUser) {
+        var base64 = JsonUtil.toJson(event);
+        var data = new TikTokDataTable();
+        data.setSessionTag(dataCollectorModel.getSessionTag());
+        data.setTiktokUser(tiktokUser);
+        data.setDataType("event");
+        data.setDataTypeName(event.getClass().getSimpleName());
+        data.setContent(base64);
+        return data;
+    }
+}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/client/TikTokDataCollectorBuilder.java

@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package io.github.jwdeveloper.tiktok.tools.collector.client;
+
+import com.google.protobuf.GeneratedMessageV3;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
+import io.github.jwdeveloper.tiktok.tools.collector.api.DataCollectorBuilder;
+import io.github.jwdeveloper.tiktok.tools.collector.api.DataCollector;
+import io.github.jwdeveloper.tiktok.tools.collector.api.TikTokDataCollectorModel;
+import io.github.jwdeveloper.tiktok.tools.db.TikTokDatabase;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+public class TikTokDataCollectorBuilder implements DataCollectorBuilder {
+
+
+    TikTokDataCollectorModel dataModel;
+
+    TikTokDatabase database;
+
+    public TikTokDataCollectorBuilder(String outputName) {
+
+        dataModel = new TikTokDataCollectorModel();
+        dataModel.setOutputName(outputName);
+        dataModel.setUsers(new ArrayList<>());
+        dataModel.setEventsFilter(new HashSet<>());
+        dataModel.setMessagesFilter(new HashSet<>());
+        dataModel.setOutputPath("...");
+        dataModel.setOnConfigureLiveClient((e) -> {
+        });
+    }
+
+    @Override
+    public DataCollectorBuilder addUser(String user) {
+        dataModel.getUsers().add(user);
+        return this;
+    }
+
+    @Override
+    public TikTokDataCollectorBuilder addMessageFilter(Class<? extends GeneratedMessageV3> message) {
+        dataModel.getMessagesFilter().add(message.getSimpleName());
+        return this;
+    }
+
+    @Override
+    public TikTokDataCollectorBuilder addMessageFilter(String message) {
+        dataModel.getMessagesFilter().add(message);
+        return this;
+    }
+
+    @Override
+    public TikTokDataCollectorBuilder addEventFilter(Class<? extends TikTokEvent> event) {
+        dataModel.getEventsFilter().add(event.getSimpleName());
+        return this;
+    }
+
+    @Override
+    public TikTokDataCollectorBuilder addEventFilter(String event) {
+        dataModel.getEventsFilter().add(event);
+        return this;
+    }
+
+
+    @Override
+    public DataCollectorBuilder setOutputPath(String path) {
+        dataModel.setOutputPath(path);
+        return this;
+    }
+
+    @Override
+    public DataCollectorBuilder setSessionTag(String sessionTimestamp) {
+        dataModel.setSessionTag(sessionTimestamp);
+        return this;
+    }
+
+    @Override
+    public DataCollectorBuilder setDatabase(TikTokDatabase database)
+    {
+        this.database =database;
+        return this;
+    }
+
+    @Override
+    public DataCollectorBuilder configureLiveClient(Consumer<LiveClientBuilder> consumer) {
+        dataModel.setOnConfigureLiveClient(consumer);
+        return this;
+    }
+
+
+    @Override
+    public DataCollector buildAndRun() {
+
+        var collector = build();
+        collector.connect();
+        return collector;
+    }
+
+    @Override
+    public DataCollector build() {
+
+        if (dataModel.getSessionTag().isEmpty()) {
+            dataModel.setSessionTag(UUID.randomUUID().toString());
+        }
+
+        if(database == null)
+        {
+            database =  new TikTokDatabase(dataModel.getOutputName());
+        }
+        var dataCollector = new TikTokDataCollector(dataModel, database);
+        return dataCollector;
+    }
+
+
+}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/client/TikTokMessagessCollectorBuilder.java

@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.tools.collector.client;
-
-import io.github.jwdeveloper.tiktok.TikTokLiveClientBuilder;
-import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
-import io.github.jwdeveloper.tiktok.tools.collector.db.TikTokDatabase;
-
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-
-public class TikTokMessagessCollectorBuilder {
-    List<String> users;
-    String outputFileName;
-    List<Class<?>> filters;
-    Consumer<LiveClientBuilder> onBuilder;
-    List<LiveClient> tiktokclients;
-
-    MessageCollector messageCollector;
-
-    public TikTokMessagessCollectorBuilder(String outputName) {
-        users = new ArrayList<>();
-        outputFileName = outputName;
-        filters = new ArrayList<>();
-        onBuilder = (e) -> {
-        };
-        tiktokclients = new ArrayList<>();
-        messageCollector = new MessageCollector(outputName);
-    }
-
-    public TikTokMessagessCollectorBuilder(MessageCollector messageCollector, String outputFileName) {
-        this(outputFileName);
-        this.messageCollector = messageCollector;
-    }
-
-    public TikTokMessagessCollectorBuilder setOutputName(String name) {
-        outputFileName = name;
-        return this;
-    }
-
-
-    public TikTokMessagessCollectorBuilder addOnBuilder(Consumer<LiveClientBuilder> consumer) {
-        onBuilder = consumer;
-        return this;
-    }
-
-    public TikTokMessagessCollectorBuilder addUser(String user) {
-        users.add(user);
-        return this;
-    }
-
-    public TikTokMessagessCollectorBuilder addEventFilter(Class<?> event) {
-        filters.add(event);
-        return this;
-    }
-
-    public MessageCollector buildAndRun() throws SQLException {
-        var db = new TikTokDatabase(outputFileName);
-        db.init();
-        var factory = new TikTokClientFactory(messageCollector, db);
-        for (var user : users) {
-            var client = factory.runClientAsync(user,filters, onBuilder);
-            client.thenAccept(liveClient ->
-            {
-                tiktokclients.add(liveClient);
-            });
-        }
-        return messageCollector;
-    }
-
-    public void stop() {
-        for (var client : tiktokclients) {
-            client.disconnect();
-        }
-    }
-}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/db/TikTokDatabase.java

@@ -1,92 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.tools.collector.db;
-
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokErrorModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokMessageModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokResponseModel;
-import org.jdbi.v3.core.Jdbi;
-import org.jdbi.v3.sqlobject.SqlObjectPlugin;
-
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.List;
-
-public class TikTokDatabase {
-    private final String database;
-    private TikTokMessageModelDAO messagesTable;
-    private TikTokErrorModelDAO errorTable;
-    private TikTokResponseModelDAO responseTable;
-
-    public TikTokDatabase(String database) {
-        this.database = database;
-    }
-
-    public void init() throws SQLException {
-        var jdbcUrl = "jdbc:sqlite:" + database + ".db";
-        DriverManager.getConnection(jdbcUrl);
-        var jdbi = Jdbi.create(jdbcUrl)
-                .installPlugin(new SqlObjectPlugin());
-        jdbi.useHandle(handle -> {
-            handle.execute(SqlConsts.CREATE_MESSAGES_TABLE);
-            handle.execute(SqlConsts.CREATE_ERROR_TABLE);
-            handle.execute(SqlConsts.CREATE_RESPONSE_MODEL);
-        });
-        messagesTable = jdbi.onDemand(TikTokMessageModelDAO.class);
-        errorTable = jdbi.onDemand(TikTokErrorModelDAO.class);
-        responseTable = jdbi.onDemand(TikTokResponseModelDAO.class);
-    }
-
-    public void insertMessage(TikTokMessageModel message) {
-        message.setCreatedAt(getTime());
-        messagesTable.insertTikTokMessage(message);
-    }
-
-    public void insertError(TikTokErrorModel message) {
-        message.setCreatedAt(getTime());
-        errorTable.insertTikTokMessage(message);
-    }
-
-    public void insertResponse(TikTokResponseModel message) {
-        message.setCreatedAt(getTime());
-        responseTable.insert(message);
-    }
-
-    public List<TikTokErrorModel> selectErrors() {
-        return errorTable.selectErrors();
-    }
-
-    public List<TikTokMessageModel> selectMessages() {
-        return messagesTable.select();
-    }
-
-    public List<TikTokResponseModel> selectResponces() {
-        return responseTable.select();
-    }
-
-    private String getTime() {
-        return new SimpleDateFormat("dd:MM:yyyy HH:mm:ss.SSS").format(new Date());
-    }
-}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/db/TikTokMessageModelDAO.java

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.tools.collector.db;
-
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokErrorModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokMessageModel;
-import org.jdbi.v3.sqlobject.config.RegisterBeanMapper;
-import org.jdbi.v3.sqlobject.customizer.BindBean;
-import org.jdbi.v3.sqlobject.statement.SqlQuery;
-import org.jdbi.v3.sqlobject.statement.SqlUpdate;
-
-import java.util.List;
-
-@RegisterBeanMapper(TikTokMessageModel.class)
-public interface TikTokMessageModelDAO
-{
-    @SqlUpdate("INSERT INTO TikTokMessageModel (hostName, eventName,type, eventContent, createdAt) " +
-            "VALUES (:hostName, :eventName, :type, :eventContent, :createdAt)")
-    void insertTikTokMessage(@BindBean TikTokMessageModel message);
-
-    @SqlQuery("SELECT * FROM TikTokMessageModel")
-    List<TikTokMessageModel> select();
-}

Tools-EventsCollector/src/main/java/io/github/jwdeveloper/tiktok/tools/collector/db/TikTokResponseModelDAO.java

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2023-2023 jwdeveloper jacekwoln@gmail.com
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-package io.github.jwdeveloper.tiktok.tools.collector.db;
-
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokMessageModel;
-import io.github.jwdeveloper.tiktok.tools.collector.tables.TikTokResponseModel;
-import org.jdbi.v3.sqlobject.config.RegisterBeanMapper;
-import org.jdbi.v3.sqlobject.customizer.BindBean;
-import org.jdbi.v3.sqlobject.statement.SqlQuery;
-import org.jdbi.v3.sqlobject.statement.SqlUpdate;
-
-import java.util.List;
-
-@RegisterBeanMapper(TikTokResponseModel.class)
-public interface TikTokResponseModelDAO
-{
-    @SqlUpdate("INSERT INTO TikTokResponseModel (hostName, response, createdAt) " +
-            "VALUES (:hostName, :response, :createdAt)")
-    void insert(@BindBean TikTokResponseModel message);
-
-    @SqlQuery("SELECT * FROM TikTokResponseModel")
-    List<TikTokResponseModel> select();
-}