Simplify adding events to TikTok Builder,

checkout `EventsBuilder`

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

@@ -22,8 +22,8 @@
  */
 package io.github.jwdeveloper.tiktok.live.builder;
 
-import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.*;
+import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.data.events.control.TikTokPreConnectionEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftComboEvent;
 import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
@@ -55,7 +55,9 @@ public interface EventsBuilder<T> {
      * @param action consumable action
      * @return self instance
      */
-    T onEvent(EventConsumer<TikTokEvent> action);
+    default T onEvent(EventConsumer<TikTokEvent> action) {
+        return onEvent(TikTokEvent.class, action);
+    }
 
     /**
      * Invoked when information about room (live) got updated such as viewer count, etc..
@@ -63,113 +65,171 @@ public interface EventsBuilder<T> {
      * @param action consumable action
      * @return self instance
      */
-    T onRoomInfo(EventConsumer<TikTokRoomInfoEvent> action);
+    default T onRoomInfo(EventConsumer<TikTokRoomInfoEvent> action) {
+        return onEvent(TikTokRoomInfoEvent.class, action);
+    }
 
     /**
      * Invoked when someone send message to chat
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onComment(EventConsumer<TikTokCommentEvent> action);
+    default T onComment(EventConsumer<TikTokCommentEvent> action) {
+        return onEvent(TikTokCommentEvent.class, action);
+    }
 
     /**
      * Invoked when TikTokLiveJava makes http request and getting response
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action);
+    default T onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
+        return onEvent(TikTokHttpResponseEvent.class, action);
+    }
 
     /**
      * Invoked when TikTok protocolBuffer data "message" was successfully mapped to event
      * events contains protocol-buffer "Message"  and  TikTokLiveJava "Event"
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> action);
+    default T onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> action) {
+        return onEvent(TikTokWebsocketMessageEvent.class, action);
+    }
 
     /**
      * Invoked when there was not found event mapper for TikTok protocolBuffer data "message"
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> action);
+    default T onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> action) {
+        return onEvent(TikTokWebsocketUnhandledMessageEvent.class, action);
+    }
 
     /**
      * Invoked every time TikTok sends protocolBuffer data to websocket
      * Response contains list of messages that are later mapped to events
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> action);
+    default T onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> action) {
+        return onEvent(TikTokWebsocketResponseEvent.class, action);
+    }
 
     /**
      * Invoked for gifts that has no combo, or when combo finishes
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onGift(EventConsumer<TikTokGiftEvent> action);
+    default T onGift(EventConsumer<TikTokGiftEvent> action) {
+        return onEvent(TikTokGiftEvent.class, action);
+    }
 
     /**
      * Invoked for gifts that has combo options such as roses
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onGiftCombo(EventConsumer<TikTokGiftComboEvent> action);
+    default T onGiftCombo(EventConsumer<TikTokGiftComboEvent> action) {
+        return onEvent(TikTokGiftComboEvent.class, action);
+    }
 
-    T onQuestion(EventConsumer<TikTokQuestionEvent> action);
+    default T onQuestion(EventConsumer<TikTokQuestionEvent> action) {
+        return onEvent(TikTokQuestionEvent.class, action);
+    }
 
-    T onSubscribe(EventConsumer<TikTokSubscribeEvent> action);
+    default T onSubscribe(EventConsumer<TikTokSubscribeEvent> action) {
+        return onEvent(TikTokSubscribeEvent.class, action);
+    }
 
-    T onFollow(EventConsumer<TikTokFollowEvent> action);
+    default T onFollow(EventConsumer<TikTokFollowEvent> action) {
+        return onEvent(TikTokFollowEvent.class, action);
+    }
 
-    T onLike(EventConsumer<TikTokLikeEvent> action);
+    default T onLike(EventConsumer<TikTokLikeEvent> action) {
+        return onEvent(TikTokLikeEvent.class, action);
+    }
 
-    T onEmote(EventConsumer<TikTokEmoteEvent> action);
+    default T onEmote(EventConsumer<TikTokEmoteEvent> action) {
+        return onEvent(TikTokEmoteEvent.class, action);
+    }
 
-    T onJoin(EventConsumer<TikTokJoinEvent> action);
+    default T onJoin(EventConsumer<TikTokJoinEvent> action) {
+        return onEvent(TikTokJoinEvent.class, action);
+    }
 
-    T onShare(EventConsumer<TikTokShareEvent> action);
+    default T onShare(EventConsumer<TikTokShareEvent> action) {
+        return onEvent(TikTokShareEvent.class, action);
+    }
 
-    T onLivePaused(EventConsumer<TikTokLivePausedEvent> action);
+    default T onLivePaused(EventConsumer<TikTokLivePausedEvent> action) {
+        return onEvent(TikTokLivePausedEvent.class, action);
+    }
 
-    T onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> action);
+    default T onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> action) {
+        return onEvent(TikTokLiveUnpausedEvent.class, action);
+    }
 
-    T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> action);
+    default T onLiveEnded(EventConsumer<TikTokLiveEndedEvent> action) {
+        return onEvent(TikTokLiveEndedEvent.class, action);
+    }
 
     /**
      * Invoked when client has been successfully connected to live
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onConnected(EventConsumer<TikTokConnectedEvent> action);
+    default T onConnected(EventConsumer<TikTokConnectedEvent> action) {
+        return onEvent(TikTokConnectedEvent.class, action);
+    }
 
     /**
      * Invoked before client has been successfully connected to live
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onPreConnection(EventConsumer<TikTokPreConnectionEvent> action);
+    default T onPreConnection(EventConsumer<TikTokPreConnectionEvent> action) {
+        return onEvent(TikTokPreConnectionEvent.class, action);
+    }
 
     /**
      * Invoked when client tries to reconnect
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onReconnecting(EventConsumer<TikTokReconnectingEvent> action);
+    default T onReconnecting(EventConsumer<TikTokReconnectingEvent> action) {
+        return onEvent(TikTokReconnectingEvent.class, action);
+    }
 
     /**
      * Invoked when client disconnected
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onDisconnected(EventConsumer<TikTokDisconnectedEvent> action);
+    default T onDisconnected(EventConsumer<TikTokDisconnectedEvent> action) {
+        return onEvent(TikTokDisconnectedEvent.class, action);
+    }
 
     /**
      * Invoked when exception was throed inside client or event handler
+     *
      * @param action consumable action
      * @return self instance
      */
-    T onError(EventConsumer<TikTokErrorEvent> action);
+    default T onError(EventConsumer<TikTokErrorEvent> action) {
+        return onEvent(TikTokErrorEvent.class, action);
+    }
 
 
     // TODO Figure out how those events works
@@ -216,4 +276,10 @@ public interface EventsBuilder<T> {
     //T onLinkMicBattle(TikTokEventConsumer<TikTokLinkMicBattleEvent> event);
 
     //T onUnhandledControl(TikTokEventConsumer<TikTokUnhandledControlEvent> event);
+
+    /**
+     * To do figure out how to use Annotation processor.
+     * Goal is to generates methods for all possible events, everytime library is compiled
+     */
+
 }

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

@@ -189,365 +189,9 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return build().connectAsync();
     }
 
-    /**
-     * To do figure out how to use Annotation processor.
-     * Goal is to generates methods for all possible events, everytime library is compiled
-     */
-    public TikTokLiveClientBuilder onUnhandledSocial(EventConsumer<TikTokUnhandledSocialEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledSocialEvent.class, event);
-        return this;
-    }
-
-    public LiveClientBuilder onChest(EventConsumer<TikTokChestEvent> event) {
-        eventHandler.subscribe(TikTokChestEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicFanTicket(EventConsumer<TikTokLinkMicFanTicketEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicFanTicketEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onEnvelope(EventConsumer<TikTokEnvelopeEvent> event) {
-        eventHandler.subscribe(TikTokEnvelopeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onShop(EventConsumer<TikTokShopEvent> event) {
-        eventHandler.subscribe(TikTokShopEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onDetect(EventConsumer<TikTokDetectEvent> event) {
-        eventHandler.subscribe(TikTokDetectEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkLayer(EventConsumer<TikTokLinkLayerEvent> event) {
-        eventHandler.subscribe(TikTokLinkLayerEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onConnected(EventConsumer<TikTokConnectedEvent> event) {
-        eventHandler.subscribe(TikTokConnectedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onPreConnection(EventConsumer<TikTokPreConnectionEvent> event) {
-        eventHandler.subscribe(TikTokPreConnectionEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onCaption(EventConsumer<TikTokCaptionEvent> event) {
-        eventHandler.subscribe(TikTokCaptionEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onQuestion(EventConsumer<TikTokQuestionEvent> event) {
-        eventHandler.subscribe(TikTokQuestionEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onRoomPin(EventConsumer<TikTokRoomPinEvent> event) {
-        eventHandler.subscribe(TikTokRoomPinEvent.class, event);
-        return this;
-    }
-
     @Override
-    public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> event) {
-        eventHandler.subscribe(eventClass, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onRoomInfo(EventConsumer<TikTokRoomInfoEvent> event) {
-        eventHandler.subscribe(TikTokRoomInfoEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLivePaused(EventConsumer<TikTokLivePausedEvent> event) {
-        eventHandler.subscribe(TikTokLivePausedEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onLiveUnpaused(EventConsumer<TikTokLiveUnpausedEvent> event) {
-        eventHandler.subscribe(TikTokLiveUnpausedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLike(EventConsumer<TikTokLikeEvent> event) {
-        eventHandler.subscribe(TikTokLikeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLink(EventConsumer<TikTokLinkEvent> event) {
-        eventHandler.subscribe(TikTokLinkEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkInvite(EventConsumer<TikTokLinkInviteEvent> event) {
-        eventHandler.subscribe(TikTokLinkInviteEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkReply(EventConsumer<TikTokLinkReplyEvent> event) {
-        eventHandler.subscribe(TikTokLinkReplyEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkCreate(EventConsumer<TikTokLinkCreateEvent> event) {
-        eventHandler.subscribe(TikTokLinkCreateEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkClose(EventConsumer<TikTokLinkCloseEvent> event) {
-        eventHandler.subscribe(TikTokLinkCloseEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkEnter(EventConsumer<TikTokLinkEnterEvent> event) {
-        eventHandler.subscribe(TikTokLinkEnterEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkLeave(EventConsumer<TikTokLinkLeaveEvent> event) {
-        eventHandler.subscribe(TikTokLinkLeaveEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkCancel(EventConsumer<TikTokLinkCancelEvent> event) {
-        eventHandler.subscribe(TikTokLinkCancelEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkKickOut(EventConsumer<TikTokLinkKickOutEvent> event) {
-        eventHandler.subscribe(TikTokLinkKickOutEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkLinkedListChange(EventConsumer<TikTokLinkLinkedListChangeEvent> event) {
-        eventHandler.subscribe(TikTokLinkLinkedListChangeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkUpdateUser(EventConsumer<TikTokLinkUpdateUserEvent> event) {
-        eventHandler.subscribe(TikTokLinkUpdateUserEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkWaitListChange(EventConsumer<TikTokLinkWaitListChangeEvent> event) {
-        eventHandler.subscribe(TikTokLinkWaitListChangeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMute(EventConsumer<TikTokLinkMuteEvent> event) {
-        eventHandler.subscribe(TikTokLinkMuteEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkRandomMatch(EventConsumer<TikTokLinkRandomMatchEvent> event) {
-        eventHandler.subscribe(TikTokLinkRandomMatchEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkUpdateUserSettings(EventConsumer<TikTokLinkUpdateUserSettingEvent> event) {
-        eventHandler.subscribe(TikTokLinkUpdateUserSettingEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicIdxUpdate(EventConsumer<TikTokLinkMicIdxUpdateEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicIdxUpdateEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkListChange(EventConsumer<TikTokLinkListChangeEvent> event) {
-        eventHandler.subscribe(TikTokLinkListChangeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkCohostListChange(EventConsumer<TikTokLinkCohostListChangeEvent> event) {
-        eventHandler.subscribe(TikTokLinkCohostListChangeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMediaChange(EventConsumer<TikTokLinkMediaChangeEvent> event) {
-        eventHandler.subscribe(TikTokLinkMediaChangeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkAcceptNotice(EventConsumer<TikTokLinkAcceptNoticeEvent> event) {
-        eventHandler.subscribe(TikTokLinkAcceptNoticeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkSysKickOut(EventConsumer<TikTokLinkSysKickOutEvent> event) {
-        eventHandler.subscribe(TikTokLinkSysKickOutEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkUserToast(EventConsumer<TikTokLinkUserToastEvent> event) {
-        eventHandler.subscribe(TikTokLinkUserToastEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onBarrage(EventConsumer<TikTokBarrageEvent> event) {
-        eventHandler.subscribe(TikTokBarrageEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onGift(EventConsumer<TikTokGiftEvent> event) {
-        eventHandler.subscribe(TikTokGiftEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onGiftCombo(EventConsumer<TikTokGiftComboEvent> event) {
-        eventHandler.subscribe(TikTokGiftComboEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicArmies(EventConsumer<TikTokLinkMicArmiesEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicArmiesEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onEmote(EventConsumer<TikTokEmoteEvent> event) {
-        eventHandler.subscribe(TikTokEmoteEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onUnauthorizedMember(EventConsumer<TikTokUnauthorizedMemberEvent> event) {
-        eventHandler.subscribe(TikTokUnauthorizedMemberEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onInRoomBanner(EventConsumer<TikTokInRoomBannerEvent> event) {
-        eventHandler.subscribe(TikTokInRoomBannerEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicMethod(EventConsumer<TikTokLinkMicMethodEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicMethodEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onSubscribe(EventConsumer<TikTokSubscribeEvent> event) {
-        eventHandler.subscribe(TikTokSubscribeEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onPoll(EventConsumer<TikTokPollEvent> event) {
-        eventHandler.subscribe(TikTokPollEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onFollow(EventConsumer<TikTokFollowEvent> event) {
-        eventHandler.subscribe(TikTokFollowEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onComment(EventConsumer<TikTokCommentEvent> event) {
-        eventHandler.subscribe(TikTokCommentEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public LiveClientBuilder onHttpResponse(EventConsumer<TikTokHttpResponseEvent> action) {
-        eventHandler.subscribe(TikTokHttpResponseEvent.class, action);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onGoalUpdate(EventConsumer<TikTokGoalUpdateEvent> event) {
-        eventHandler.subscribe(TikTokGoalUpdateEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onRankUpdate(EventConsumer<TikTokRankUpdateEvent> event) {
-        eventHandler.subscribe(TikTokRankUpdateEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onIMDelete(EventConsumer<TikTokIMDeleteEvent> event) {
-        eventHandler.subscribe(TikTokIMDeleteEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLiveEnded(EventConsumer<TikTokLiveEndedEvent> event) {
-        eventHandler.subscribe(TikTokLiveEndedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onError(EventConsumer<TikTokErrorEvent> event) {
-        eventHandler.subscribe(TikTokErrorEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onJoin(EventConsumer<TikTokJoinEvent> event) {
-        eventHandler.subscribe(TikTokJoinEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onRankText(EventConsumer<TikTokRankTextEvent> event) {
-        eventHandler.subscribe(TikTokRankTextEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onShare(EventConsumer<TikTokShareEvent> event) {
-        eventHandler.subscribe(TikTokShareEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onUnhandledMember(EventConsumer<TikTokUnhandledMemberEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledMemberEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onSubNotify(EventConsumer<TikTokSubNotifyEvent> event) {
-        eventHandler.subscribe(TikTokSubNotifyEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onLinkMicBattle(EventConsumer<TikTokLinkMicBattleEvent> event) {
-        eventHandler.subscribe(TikTokLinkMicBattleEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onDisconnected(EventConsumer<TikTokDisconnectedEvent> event) {
-        eventHandler.subscribe(TikTokDisconnectedEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onUnhandledControl(EventConsumer<TikTokUnhandledControlEvent> event) {
-        eventHandler.subscribe(TikTokUnhandledControlEvent.class, event);
-        return this;
-    }
-
-    public TikTokLiveClientBuilder onEvent(EventConsumer<TikTokEvent> event) {
-        eventHandler.subscribe(TikTokEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onWebsocketResponse(EventConsumer<TikTokWebsocketResponseEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketResponseEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onWebsocketMessage(EventConsumer<TikTokWebsocketMessageEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketMessageEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onWebsocketUnhandledMessage(EventConsumer<TikTokWebsocketUnhandledMessageEvent> event) {
-        eventHandler.subscribe(TikTokWebsocketUnhandledMessageEvent.class, event);
-        return this;
-    }
-
-    @Override
-    public TikTokLiveClientBuilder onReconnecting(EventConsumer<TikTokReconnectingEvent> event) {
-        eventHandler.subscribe(TikTokReconnectingEvent.class, event);
+    public <E extends TikTokEvent> LiveClientBuilder onEvent(Class<E> eventClass, EventConsumer<E> action) {
+        eventHandler.subscribe(eventClass, action);
         return this;
     }
 }

Tools-ReadmeGenerator/pom.xml

@@ -23,10 +23,16 @@
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.13.0</version>
+            <scope>compile</scope>
+        </dependency>
         <dependency>
             <groupId>com.github.jwdeveloper.Descrabble</groupId>
             <artifactId>Descrabble-Full</artifactId>
-            <version>0.0.7-Release</version>
+            <version>0.0.11-Release</version>
             <scope>compile</scope>
         </dependency>
         <dependency>

Tools-ReadmeGenerator/src/main/java/io/github/jwdeveloper/tiktok/EventsDecorator.java

@@ -0,0 +1,12 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.descrabble.api.DescriptionDecorator;
+import io.github.jwdeveloper.descrabble.api.elements.Element;
+import io.github.jwdeveloper.descrabble.api.elements.ElementFactory;
+
+public class EventsDecorator implements DescriptionDecorator {
+    @Override
+    public void decorate(Element root, ElementFactory factory) {
+
+    }
+}

Tools-ReadmeGenerator/src/main/java/io/github/jwdeveloper/tiktok/Main.java

@@ -0,0 +1,37 @@
+package io.github.jwdeveloper.tiktok;
+
+import io.github.jwdeveloper.descrabble.api.DescriptionGenerator;
+import io.github.jwdeveloper.descrabble.framework.Descrabble;
+import io.github.jwdeveloper.descrabble.plugin.github.DescrabbleGithub;
+import org.apache.commons.io.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Main
+{
+    public static void main(String[] args) throws IOException {
+        var version = System.getenv("VERSION");
+        if (version == null || version.equals("")) {
+            version = "[Replace with current version]";
+        }
+
+        var inputStream = Main.class.getResourceAsStream("/readme-template.html");
+        var targetFile = new File("temp.file");
+        FileUtils.copyInputStreamToFile(inputStream, targetFile);
+
+        var output = System.getProperty("user.dir");
+
+        DescriptionGenerator generator = Descrabble.create()
+                .withTemplate(targetFile)
+                .withVariable("version", version)
+                .withDecorator(new EventsDecorator())
+                .withPlugin(DescrabbleGithub.plugin("README.md"))
+                .build();
+
+
+        generator.generate(output);
+        targetFile.delete();
+        inputStream.close();
+    }
+}

Tools-ReadmeGenerator/src/main/java/io/github/jwdeveloper/tiktok/ReadmeGenerator.java

@@ -51,10 +51,6 @@ public class ReadmeGenerator {
         return version == null ? "NOT_FOUND" : version;
     }
 
-    public String getCodeExample(String path) {
-        var content = FilesUtility.loadFileContent(path);
-        content = content.substring(content.indexOf("*/") + 2);
-        return content;
-    }
+
 
 }

Tools-ReadmeGenerator/src/main/resources/readme-template.html

@@ -0,0 +1,66 @@
+<container>
+    <image width="15%"
+           image="https://raw.githubusercontent.com/jwdeveloper/DepenDance/master/Tools-Readme/src/main/resources/logo.svg">
+    </image>
+</container>
+
+
+<container>
+    <title>TikTok Live Java</title>
+    <br>
+    <i align="center">*❤️❤️🎁 *Connect to TikTok live in 3 lines* 🎁❤️❤️*</i>
+    <br>
+    <container>
+        <image width="20%" image="https://jitpack.io/v/jwdeveloper/DepenDance.svg"
+               open="https://jitpack.io/#jwdeveloper/DepenDance"></image>
+        <image image="https://img.shields.io/badge/Discord-%235865F2.svg?style=for-the-badge&logo=discord&logoColor=white"
+               open="https://discord.gg/2hu6fPPeF7"></image>
+        <image image="https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=openjdk&logoColor=white"></image>
+    </container>
+</container>
+
+
+<br>
+<code language="xml">
+    <repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+    </repositories>
+    <dependency>
+        <groupId>com.github.jwdeveloper.TikTok-Live-Java</groupId>
+        <artifactId>Client</artifactId>
+        <version>{{version}}</version>
+        <scope>compile</scope>
+    </dependency>
+</code>
+<br>
+
+
+<text>Lightweight dependency injection container that is both small and performance efficient</text>
+
+<title>Features</title>
+<br>
+<text>- [x] Injecting object via constructor</text>
+<br>
+<text>- [x] Method object providers</text>
+<br>
+<text>- [x] Class Scanner to avoid manual registration [Scanner](#autoscan)</text>
+<br>
+<text>- [x] You need to get [List of objects](#lists) in the constructor, no problem</text>
+<br>
+<text>- [x] Create [object instance](#object-instances) by yourself and register it to container!</text>
+<br>
+<text>- [x] Object lifetimes [SINGLETON, TRANSIENT] [see](#basic)</text>
+<br>
+<text>- [x] [Generic types](#generic-types)</text>
+<br>
+<text>- [x] [Many constructors](#manyconstructors)</text>
+<br>
+<text>- [x] Highly customizable, adjust container with build in [events](#events) system</text>
+<br>
+
+<title>Tutorial</title>
+
+