Breaking changes:

'Gift': changed from class to enum, so now you can handle incoming gifts in switch `Events` - new: onGiftComboFinished - Removed: onGiftBrodcast - Rename: onGiftMessage -> onGift onRoomPinMessage -> onRoomPin onRoomMessage -> onRoom onLinkMessage -> onLink onBarrageMessage -> onBarrage onPollMessage -> onPoll onShopMessage -> onShop onDetectMessage -> onDetect `GiftManager` added: registerGift findById findByName getGifts removed: getActiveGifts
2026-02-27 08:49:40 -05:00 · 2023-10-06 02:49:33 +02:00
parent 65a2d5cfff
commit ed2af8cce7
16 changed files with 126 additions and 145 deletions
--- a/API/src/main/java/io/github/jwdeveloper/tiktok/live/events/TikTokEventBuilder.java
+++ b/API/src/main/java/io/github/jwdeveloper/tiktok/live/events/TikTokEventBuilder.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.live.events;
+package io.github.jwdeveloper.tiktok.live.builder;

 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.*;
@@ -37,59 +37,57 @@ import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketRespons
 import io.github.jwdeveloper.tiktok.data.events.websocket.TikTokWebsocketUnhandledMessageEvent;


-public interface TikTokEventBuilder<T> {
+public interface EventBuilder<T> {

-    T onRoom(TikTokEventConsumer<TikTokRoomEvent> event);
+    T onRoom(EventConsumer<TikTokRoomEvent> event);

-    T onRoomUserInfo(TikTokEventConsumer<TikTokRoomUserInfoEvent> event);
+    T onRoomUserInfo(EventConsumer<TikTokRoomUserInfoEvent> event);

-    T onComment(TikTokEventConsumer<TikTokCommentEvent> event);
+    T onComment(EventConsumer<TikTokCommentEvent> event);


-    T onWebsocketMessage(TikTokEventConsumer<TikTokWebsocketMessageEvent> event);
+    T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event);

-    T onWebsocketResponse(TikTokEventConsumer<TikTokWebsocketResponseEvent> event);
+    T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event);

-    T onWebsocketUnhandledMessage(TikTokEventConsumer<TikTokWebsocketUnhandledMessageEvent> event);
+    T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event);


-    T onGiftCombo(TikTokEventConsumer<TikTokGiftComboFinishedEvent> event);
+    T onGiftCombo(EventConsumer<TikTokGiftComboFinishedEvent> event);

-    T onGift(TikTokEventConsumer<TikTokGiftEvent> event);
+    T onGift(EventConsumer<TikTokGiftEvent> event);

-    T onQuestion(TikTokEventConsumer<TikTokQuestionEvent> event);
+    T onQuestion(EventConsumer<TikTokQuestionEvent> event);

-    T onSubscribe(TikTokEventConsumer<TikTokSubscribeEvent> event);
+    T onSubscribe(EventConsumer<TikTokSubscribeEvent> event);

-    T onFollow(TikTokEventConsumer<TikTokFollowEvent> event);
+    T onFollow(EventConsumer<TikTokFollowEvent> event);

-    T onLike(TikTokEventConsumer<TikTokLikeEvent> event);
+    T onLike(EventConsumer<TikTokLikeEvent> event);

-    T onEmote(TikTokEventConsumer<TikTokEmoteEvent> event);
+    T onEmote(EventConsumer<TikTokEmoteEvent> event);

-    T onJoin(TikTokEventConsumer<TikTokJoinEvent> event);
+    T onJoin(EventConsumer<TikTokJoinEvent> event);

-    T onShare(TikTokEventConsumer<TikTokShareEvent> event);
+    T onShare(EventConsumer<TikTokShareEvent> event);
+    T onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event);

-    T onUnhandledSocial(TikTokEventConsumer<TikTokUnhandledSocialEvent> event);
+    T onLivePaused(EventConsumer<TikTokLivePausedEvent> event);
+
+    T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event);
+
+    T onConnected(EventConsumer<TikTokConnectedEvent> event);
+
+    T onReconnecting(EventConsumer<TikTokReconnectingEvent> event);
+
+    T onDisconnected(EventConsumer<TikTokDisconnectedEvent> event);
+
+    T onError(EventConsumer<TikTokErrorEvent> event);
+
+    T onEvent(EventConsumer<TikTokEvent> event);


-    T onLivePaused(TikTokEventConsumer<TikTokLivePausedEvent> event);
-
-    T onLiveEnded(TikTokEventConsumer<TikTokLiveEndedEvent> event);
-
-    T onConnected(TikTokEventConsumer<TikTokConnectedEvent> event);
-
-    T onReconnecting(TikTokEventConsumer<TikTokReconnectingEvent> event);
-
-    T onDisconnected(TikTokEventConsumer<TikTokDisconnectedEvent> event);
-
-    T onError(TikTokEventConsumer<TikTokErrorEvent> event);
-
-    T onEvent(TikTokEventConsumer<TikTokEvent> event);
-
-
-    // TODO implement later
+    // TODO Figure out how those events works
    //T onLinkMicFanTicket(TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event);

    //T onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event);
@@ -102,8 +100,6 @@ public interface TikTokEventBuilder<T> {

    //T onCaption(TikTokEventConsumer<TikTokCaptionEvent> event);

-
-
    //T onRoomPin(TikTokEventConsumer<TikTokRoomPinEvent> event);

    //T onBarrage(TikTokEventConsumer<TikTokBarrageEvent> event);
--- a/API/src/main/java/io/github/jwdeveloper/tiktok/live/events/TikTokEventConsumer.java
+++ b/API/src/main/java/io/github/jwdeveloper/tiktok/live/events/TikTokEventConsumer.java
@@ -20,12 +20,12 @@
 * 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.live.events;
+package io.github.jwdeveloper.tiktok.live.builder;

 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.live.LiveClient;

-public interface TikTokEventConsumer<T extends TikTokEvent>
+public interface EventConsumer<T extends TikTokEvent>
 {
     void onEvent(LiveClient liveClient, T event);
 }
--- a/API/src/main/java/io/github/jwdeveloper/tiktok/live/builder/LiveClientBuilder.java
+++ b/API/src/main/java/io/github/jwdeveloper/tiktok/live/builder/LiveClientBuilder.java
@@ -0,0 +1,21 @@
+package io.github.jwdeveloper.tiktok.live.builder;
+
+import io.github.jwdeveloper.tiktok.ClientSettings;
+import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
+import io.github.jwdeveloper.tiktok.live.LiveClient;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+
+public interface LiveClientBuilder extends EventBuilder<LiveClientBuilder>
+{
+
+    LiveClientBuilder configure(Consumer<ClientSettings> consumer);
+
+    LiveClientBuilder addListener(TikTokEventListener listener);
+
+    LiveClient build();
+    LiveClient buildAndConnect();
+
+    CompletableFuture<LiveClient> buildAndConnectAsync();
+}
--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLive.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLive.java
@@ -23,11 +23,12 @@
 package io.github.jwdeveloper.tiktok;


+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;

 public class TikTokLive
 {
-    public static TikTokLiveClientBuilder newClient(String userName)
+    public static LiveClientBuilder newClient(String hostName)
    {
-        return new TikTokLiveClientBuilder(userName);
+        return new TikTokLiveClientBuilder(hostName);
    }
 }
--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClientBuilder.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClientBuilder.java
@@ -23,8 +23,8 @@
 package io.github.jwdeveloper.tiktok;

 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventBuilder;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventBuilder;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
@@ -53,6 +53,7 @@ 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.LiveClient;
+import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
 import io.github.jwdeveloper.tiktok.utils.ConsoleColors;
 import io.github.jwdeveloper.tiktok.websocket.TikTokWebSocketClient;

@@ -63,7 +64,9 @@ import java.util.concurrent.CompletableFuture;
 import java.util.function.Consumer;
 import java.util.logging.*;

-public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveClientBuilder> {
+public class TikTokLiveClientBuilder implements LiveClientBuilder
+{
+
    protected final ClientSettings clientSettings;
    protected final Logger logger;
    protected final TikTokEventObserver tikTokEventHandler;
@@ -172,249 +175,249 @@ public class TikTokLiveClientBuilder implements TikTokEventBuilder<TikTokLiveCli
    }

    public TikTokLiveClientBuilder onUnhandledSocial(
-            TikTokEventConsumer<TikTokUnhandledSocialEvent> event) {
+            EventConsumer<TikTokUnhandledSocialEvent> event) {
        tikTokEventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onLinkMicFanTicket(
-            TikTokEventConsumer<TikTokLinkMicFanTicketEvent> event) {
+            EventConsumer<TikTokLinkMicFanTicketEvent> event) {
        tikTokEventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onEnvelope(TikTokEventConsumer<TikTokEnvelopeEvent> event) {
+    public TikTokLiveClientBuilder onEnvelope(EventConsumer<TikTokEnvelopeEvent> event) {
        tikTokEventHandler.subscribe(TikTokEnvelopeEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onShop(TikTokEventConsumer<TikTokShopEvent> event) {
+    public TikTokLiveClientBuilder onShop(EventConsumer<TikTokShopEvent> event) {
        tikTokEventHandler.subscribe(TikTokShopEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onDetect(
-            TikTokEventConsumer<TikTokDetectEvent> event) {
+            EventConsumer<TikTokDetectEvent> event) {
        tikTokEventHandler.subscribe(TikTokDetectEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onLinkLayer(
-            TikTokEventConsumer<TikTokLinkLayerEvent> event) {
+            EventConsumer<TikTokLinkLayerEvent> event) {
        tikTokEventHandler.subscribe(TikTokLinkLayerEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onConnected(TikTokEventConsumer<TikTokConnectedEvent> event) {
+    public TikTokLiveClientBuilder onConnected(EventConsumer<TikTokConnectedEvent> event) {
        tikTokEventHandler.subscribe(TikTokConnectedEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onCaption(TikTokEventConsumer<TikTokCaptionEvent> event) {
+    public TikTokLiveClientBuilder onCaption(EventConsumer<TikTokCaptionEvent> event) {
        tikTokEventHandler.subscribe(TikTokCaptionEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onQuestion(TikTokEventConsumer<TikTokQuestionEvent> event) {
+    public TikTokLiveClientBuilder onQuestion(EventConsumer<TikTokQuestionEvent> event) {
        tikTokEventHandler.subscribe(TikTokQuestionEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onRoomPin(
-            TikTokEventConsumer<TikTokRoomPinEvent> event) {
+            EventConsumer<TikTokRoomPinEvent> event) {
        tikTokEventHandler.subscribe(TikTokRoomPinEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onRoom(TikTokEventConsumer<TikTokRoomEvent> event) {
+    public TikTokLiveClientBuilder onRoom(EventConsumer<TikTokRoomEvent> event) {
        tikTokEventHandler.subscribe(TikTokRoomEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onLivePaused(TikTokEventConsumer<TikTokLivePausedEvent> event) {
+    public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
        tikTokEventHandler.subscribe(TikTokLivePausedEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onLike(TikTokEventConsumer<TikTokLikeEvent> event) {
+    public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
        tikTokEventHandler.subscribe(TikTokLikeEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onLink(TikTokEventConsumer<TikTokLinkEvent> event) {
+    public TikTokLiveClientBuilder onLink(EventConsumer<TikTokLinkEvent> event) {
        tikTokEventHandler.subscribe(TikTokLinkEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onBarrage(
-            TikTokEventConsumer<TikTokBarrageEvent> event) {
+            EventConsumer<TikTokBarrageEvent> event) {
        tikTokEventHandler.subscribe(TikTokBarrageEvent.class, event);
        return this;
    }


-    public TikTokLiveClientBuilder onGift(TikTokEventConsumer<TikTokGiftEvent> event) {
+    public TikTokLiveClientBuilder onGift(EventConsumer<TikTokGiftEvent> event) {
        tikTokEventHandler.subscribe(TikTokGiftEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onGiftCombo(TikTokEventConsumer<TikTokGiftComboFinishedEvent> event) {
+    public TikTokLiveClientBuilder onGiftCombo(EventConsumer<TikTokGiftComboFinishedEvent> event) {
        tikTokEventHandler.subscribe(TikTokGiftComboFinishedEvent.class, event);
        return this;
    }


    public TikTokLiveClientBuilder onLinkMicArmies(
-            TikTokEventConsumer<TikTokLinkMicArmiesEvent> event) {
+            EventConsumer<TikTokLinkMicArmiesEvent> event) {
        tikTokEventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onEmote(TikTokEventConsumer<TikTokEmoteEvent> event) {
+    public TikTokLiveClientBuilder onEmote(EventConsumer<TikTokEmoteEvent> event) {
        tikTokEventHandler.subscribe(TikTokEmoteEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onUnauthorizedMember(
-            TikTokEventConsumer<TikTokUnauthorizedMemberEvent> event) {
+            EventConsumer<TikTokUnauthorizedMemberEvent> event) {
        tikTokEventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onInRoomBanner(
-            TikTokEventConsumer<TikTokInRoomBannerEvent> event) {
+            EventConsumer<TikTokInRoomBannerEvent> event) {
        tikTokEventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onLinkMicMethod(
-            TikTokEventConsumer<TikTokLinkMicMethodEvent> event) {
+            EventConsumer<TikTokLinkMicMethodEvent> event) {
        tikTokEventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onSubscribe(TikTokEventConsumer<TikTokSubscribeEvent> event) {
+    public TikTokLiveClientBuilder onSubscribe(EventConsumer<TikTokSubscribeEvent> event) {
        tikTokEventHandler.subscribe(TikTokSubscribeEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onPoll(TikTokEventConsumer<TikTokPollEvent> event) {
+    public TikTokLiveClientBuilder onPoll(EventConsumer<TikTokPollEvent> event) {
        tikTokEventHandler.subscribe(TikTokPollEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onFollow(TikTokEventConsumer<TikTokFollowEvent> event) {
+    public TikTokLiveClientBuilder onFollow(EventConsumer<TikTokFollowEvent> event) {
        tikTokEventHandler.subscribe(TikTokFollowEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onRoomUserInfo(
-            TikTokEventConsumer<TikTokRoomUserInfoEvent> event) {
+            EventConsumer<TikTokRoomUserInfoEvent> event) {
        tikTokEventHandler.subscribe(TikTokRoomUserInfoEvent.class, event);
        return this;
    }



-    public TikTokLiveClientBuilder onComment(TikTokEventConsumer<TikTokCommentEvent> event) {
+    public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
        tikTokEventHandler.subscribe(TikTokCommentEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onGoalUpdate(TikTokEventConsumer<TikTokGoalUpdateEvent> event) {
+    public TikTokLiveClientBuilder onGoalUpdate(EventConsumer<TikTokGoalUpdateEvent> event) {
        tikTokEventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
        return this;
    }
-    public TikTokLiveClientBuilder onRankUpdate(TikTokEventConsumer<TikTokRankUpdateEvent> event) {
+    public TikTokLiveClientBuilder onRankUpdate(EventConsumer<TikTokRankUpdateEvent> event) {
        tikTokEventHandler.subscribe(TikTokRankUpdateEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onIMDelete(TikTokEventConsumer<TikTokIMDeleteEvent> event) {
+    public TikTokLiveClientBuilder onIMDelete(EventConsumer<TikTokIMDeleteEvent> event) {
        tikTokEventHandler.subscribe(TikTokIMDeleteEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onLiveEnded(TikTokEventConsumer<TikTokLiveEndedEvent> event) {
+    public TikTokLiveClientBuilder onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event) {
        tikTokEventHandler.subscribe(TikTokLiveEndedEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onError(TikTokEventConsumer<TikTokErrorEvent> event) {
+    public TikTokLiveClientBuilder onError(EventConsumer<TikTokErrorEvent> event) {
        tikTokEventHandler.subscribe(TikTokErrorEvent.class, event);
        return this;
    }



-    public TikTokLiveClientBuilder onJoin(TikTokEventConsumer<TikTokJoinEvent> event) {
+    public TikTokLiveClientBuilder onJoin(EventConsumer<TikTokJoinEvent> event) {
        tikTokEventHandler.subscribe(TikTokJoinEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onRankText(TikTokEventConsumer<TikTokRankTextEvent> event) {
+    public TikTokLiveClientBuilder onRankText(EventConsumer<TikTokRankTextEvent> event) {
        tikTokEventHandler.subscribe(TikTokRankTextEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onShare(TikTokEventConsumer<TikTokShareEvent> event) {
+    public TikTokLiveClientBuilder onShare(EventConsumer<TikTokShareEvent> event) {
        tikTokEventHandler.subscribe(TikTokShareEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onUnhandledMember(
-            TikTokEventConsumer<TikTokUnhandledMemberEvent> event) {
+            EventConsumer<TikTokUnhandledMemberEvent> event) {
        tikTokEventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onSubNotify(TikTokEventConsumer<TikTokSubNotifyEvent> event) {
+    public TikTokLiveClientBuilder onSubNotify(EventConsumer<TikTokSubNotifyEvent> event) {
        tikTokEventHandler.subscribe(TikTokSubNotifyEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onLinkMicBattle(
-            TikTokEventConsumer<TikTokLinkMicBattleEvent> event) {
+            EventConsumer<TikTokLinkMicBattleEvent> event) {
        tikTokEventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onDisconnected(
-            TikTokEventConsumer<TikTokDisconnectedEvent> event) {
+            EventConsumer<TikTokDisconnectedEvent> event) {
        tikTokEventHandler.subscribe(TikTokDisconnectedEvent.class, event);
        return this;
    }

    public TikTokLiveClientBuilder onUnhandledControl(
-            TikTokEventConsumer<TikTokUnhandledControlEvent> event) {
+            EventConsumer<TikTokUnhandledControlEvent> event) {
        tikTokEventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
        return this;
    }

-    public TikTokLiveClientBuilder onEvent(TikTokEventConsumer<TikTokEvent> event) {
+    public TikTokLiveClientBuilder onEvent(EventConsumer<TikTokEvent> event) {
        tikTokEventHandler.subscribe(TikTokEvent.class, event);
        return this;
    }

    @Override
-    public TikTokLiveClientBuilder onWebsocketResponse(TikTokEventConsumer<TikTokWebsocketResponseEvent> event) {
+    public TikTokLiveClientBuilder onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event) {
        tikTokEventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
        return this;
    }
    @Override
-    public TikTokLiveClientBuilder onWebsocketMessage(TikTokEventConsumer<TikTokWebsocketMessageEvent> event) {
+    public TikTokLiveClientBuilder onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event) {
        tikTokEventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
        return this;
    }

    @Override
-    public TikTokLiveClientBuilder onWebsocketUnhandledMessage(TikTokEventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
+    public TikTokLiveClientBuilder onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
        tikTokEventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
        return this;
    }

    @Override
-    public TikTokLiveClientBuilder onReconnecting(TikTokEventConsumer<TikTokReconnectingEvent> event) {
+    public TikTokLiveClientBuilder onReconnecting(EventConsumer<TikTokReconnectingEvent> event) {
        tikTokEventHandler.subscribe(TikTokReconnectingEvent.class, event);
        return this;
    }
--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/TikTokEventObserver.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/handlers/TikTokEventObserver.java
@@ -23,7 +23,7 @@
 package io.github.jwdeveloper.tiktok.handlers;

 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.live.LiveClient;

 import java.util.HashMap;
@@ -32,7 +32,7 @@ import java.util.Map;
 import java.util.Set;

 public class TikTokEventObserver {
-    private final Map<Class<?>, Set<TikTokEventConsumer>> events;
+    private final Map<Class<?>, Set<EventConsumer>> events;

    public TikTokEventObserver() {
        events = new HashMap<>();
@@ -56,7 +56,7 @@ public class TikTokEventObserver {
        }
    }

-    public <T extends TikTokEvent> void subscribe(Class<?> clazz, TikTokEventConsumer<T> event) {
+    public <T extends TikTokEvent> void subscribe(Class<?> clazz, EventConsumer<T> event) {
        events.computeIfAbsent(clazz, e -> new HashSet<>()).add(event);
    }

@@ -64,13 +64,13 @@ public class TikTokEventObserver {
        events.remove(clazz);
    }

-    public <T extends TikTokEvent> void unsubscribe(TikTokEventConsumer<T> consumer) {
+    public <T extends TikTokEvent> void unsubscribe(EventConsumer<T> consumer) {
        for (var entry : events.entrySet()) {
            entry.getValue().remove(consumer);
        }
    }

-    public <T extends TikTokEvent> void unsubscribe(Class<?> clazz, TikTokEventConsumer<T> consumer) {
+    public <T extends TikTokEvent> void unsubscribe(Class<?> clazz, EventConsumer<T> consumer) {
        if (clazz == null) {
            return;
        }
--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/listener/ListenerBindingModel.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/listener/ListenerBindingModel.java
@@ -22,7 +22,7 @@
 */
 package io.github.jwdeveloper.tiktok.listener;

-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;

 import lombok.Value;

@@ -36,5 +36,5 @@ public class ListenerBindingModel

    TikTokEventListener listener;

-    Map<Class<?>, List<TikTokEventConsumer<?>>> events;
+    Map<Class<?>, List<EventConsumer<?>>> events;
 }
--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokListenersManager.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokListenersManager.java
@@ -25,7 +25,7 @@ package io.github.jwdeveloper.tiktok.listener;

 import io.github.jwdeveloper.tiktok.annotations.TikTokEventHandler;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
-import io.github.jwdeveloper.tiktok.live.events.TikTokEventConsumer;
+import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokEventListenerMethodException;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
 import io.github.jwdeveloper.tiktok.handlers.TikTokEventObserver;
@@ -91,7 +91,7 @@ public class TikTokListenersManager implements ListenersManager {
        var methods = Arrays.stream(clazz.getDeclaredMethods()).filter(m ->
                m.getParameterCount() == 2 &&
                        m.isAnnotationPresent(TikTokEventHandler.class)).toList();
-        var eventsMap = new HashMap<Class<?>, List<TikTokEventConsumer<?>>>();
+        var eventsMap = new HashMap<Class<?>, List<EventConsumer<?>>>();
        for (var method : methods) {
            var eventClazz = method.getParameterTypes()[1];

@@ -105,7 +105,7 @@ public class TikTokListenersManager implements ListenersManager {
                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 2nd parameter must instance of " + TikTokEvent.class.getName());
            }

-            TikTokEventConsumer eventMethodRef = (liveClient, event) ->
+            EventConsumer eventMethodRef = (liveClient, event) ->
            {
                try {
                    method.invoke(listener, liveClient, event);
@@ -113,7 +113,7 @@ public class TikTokListenersManager implements ListenersManager {
                    throw new TikTokEventListenerMethodException(e);
                }
            };
-            eventsMap.computeIfAbsent(eventClazz, (a) -> new ArrayList<TikTokEventConsumer<?>>()).add(eventMethodRef);
+            eventsMap.computeIfAbsent(eventClazz, (a) -> new ArrayList<EventConsumer<?>>()).add(eventMethodRef);
        }
        return new ListenerBindingModel(listener, eventsMap);
    }
--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/LiveRoomMetaMapper.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/LiveRoomMetaMapper.java
@@ -25,9 +25,9 @@ package io.github.jwdeveloper.tiktok.mappers;
 import com.google.gson.JsonObject;
 import io.github.jwdeveloper.tiktok.live.LiveRoomMeta;

-public class LiveRoomMetaMapper implements Mapper<JsonObject, LiveRoomMeta> 
+public class LiveRoomMetaMapper
 {
-    @Override
+
    public LiveRoomMeta map(JsonObject input) {
        var liveRoomMeta = new LiveRoomMeta();

--- a/Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/messages/TikTokLikeEventMapper.java
+++ b/Client/src/main/java/io/github/jwdeveloper/tiktok/mappers/messages/TikTokLikeEventMapper.java
@@ -1,37 +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.mappers.messages;
-
-import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
-import io.github.jwdeveloper.tiktok.mappers.Mapper;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastLikeMessage;
-
-public class TikTokLikeEventMapper implements Mapper<WebcastLikeMessage, TikTokLikeEvent>
-{
-
-
-    @Override
-    public TikTokLikeEvent map(WebcastLikeMessage webcastLikeMessage) {
-        return null;
-    }
-}
--- a/TestApplication/src/main/java/io/github/jwdeveloper/tiktok/ConfigurationExample.java
+++ b/TestApplication/src/main/java/io/github/jwdeveloper/tiktok/ConfigurationExample.java
@@ -32,7 +32,7 @@ public class ConfigurationExample {
        TikTokLive.newClient(Main.TEST_TIKTOK_USER)
                .configure(clientSettings ->
                {
-                    clientSettings.setHostName(Main.TEST_TIKTOK_USER); // TikTok user name
+                    clientSettings.setHostName(Main.TEST_TIKTOK_USER); // TikTok hostname
                    clientSettings.setClientLanguage("en"); // Language
                    clientSettings.setTimeout(Duration.ofSeconds(2)); // Connection timeout
                    clientSettings.setLogLevel(Level.ALL); // Log level
@@ -49,6 +49,7 @@ public class ConfigurationExample {
                    clientSettings.setRoomId("XXXXXXXXXXXXXXXXX");
                })
                .buildAndConnect();
+
        System.in.read();
    }
 }
--- a/TestApplication/src/main/java/io/github/jwdeveloper/tiktok/Main.java
+++ b/TestApplication/src/main/java/io/github/jwdeveloper/tiktok/Main.java
@@ -51,9 +51,9 @@ public class Main {
                    clientSettings.setRetryOnConnectionFailure(true);
                    clientSettings.setHandleExistingEvents(true);
                })
-                .onGift((liveClient, event) ->
+                .onError((liveClient, event) ->
                {
-                    var  i=0;
+
                })
                .onConnected(Main::onConnected)
                .onDisconnected(Main::onDisconnected)
--- a/TestApplication/target/classes/io/github/jwdeveloper/tiktok/ListenerExample$1.class
+++ b/TestApplication/target/classes/io/github/jwdeveloper/tiktok/ListenerExample$1.class
--- a/TestApplication/target/classes/io/github/jwdeveloper/tiktok/Main$1.class
+++ b/TestApplication/target/classes/io/github/jwdeveloper/tiktok/Main$1.class
--- a/TestApplication/target/classes/io/github/jwdeveloper/tiktok/SimpleExample$1.class
+++ b/TestApplication/target/classes/io/github/jwdeveloper/tiktok/SimpleExample$1.class
--- a/Tools-ReadmeGenerator/src/main/java/io/github/jwdeveloper/tiktok/FullEventsExampleClass.java
+++ b/Tools-ReadmeGenerator/src/main/java/io/github/jwdeveloper/tiktok/FullEventsExampleClass.java
@@ -66,10 +66,6 @@ public class FullEventsExampleClass
                .onComment((liveClient, event) ->
                {

-                })
-                .onEnvelope((liveClient, event) ->
-                {
-
                })
                .onLiveEnded((liveClient, event) ->
                {