Improvement of Listener

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

@@ -0,0 +1,18 @@
+package io.github.jwdeveloper.tiktok.annotations;
+/**
+ * HIGHEST 1
+ * HIGH 2
+ * NORMAL 3
+ * LOW 4
+ * LOWEST 5
+ */
+
+public enum Priority {
+    LOWEST(2), LOW(1), NORMAL(0), HIGH(-1), HIGHEST(-2);
+
+    public int priorityValue;
+
+    Priority(int value) {
+        this.priorityValue = value;
+    }
+}

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

@@ -26,7 +26,13 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
 @Retention(RetentionPolicy.RUNTIME)
-public @interface TikTokEventObserver
+public @interface TikTokEventObserver {
-{
 
+    Priority priority() default Priority.NORMAL;
+
+    /**
+     * when true, action is invoked on the another thread
+     * @return
+     */
+    boolean async();
 }

API/src/main/java/io/github/jwdeveloper/tiktok/listener/ListenersManager.java

@@ -27,14 +27,13 @@ import java.util.List;
 /**
  *  You can dynamically add or removing TikTokEventListener
  *
- * @see TikTokEventListener
  *
  */
 public interface ListenersManager
 {
-    List<TikTokEventListener> getListeners();
+    List<Object> getListeners();
 
-    void addListener(TikTokEventListener listener);
+    void addListener(Object listener);
 
-    void removeListener(TikTokEventListener listener);
+    void removeListener(Object listener);
 }

API/src/main/java/io/github/jwdeveloper/tiktok/listener/TikTokEventListener.java

@@ -40,7 +40,7 @@ import io.github.jwdeveloper.tiktok.live.LiveClient;
  * {@code
  * 	public static class CustomListener implements TikTokEventListener
  *  {
- *  	@TikTokEventObserver
+ *    @TikTokEventObserver
  *      public void onError(LiveClient liveClient, TikTokErrorEvent event)
  *      {
  *      	System.out.println(event.getException().getMessage());
@@ -67,7 +67,9 @@ import io.github.jwdeveloper.tiktok.live.LiveClient;
  *  }
  *  </pre>
  */
-public interface TikTokEventListener
+//TODO I think this interface can be removed, since we are using,
-{
+//annotation @TikTokEventHandler to check methods that are events
+@Deprecated(forRemoval = true, since = "This interface is not longer needed, please remove it from your class")
+public interface TikTokEventListener {
 
 }

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

@@ -54,12 +54,11 @@ public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
     LiveClientBuilder configure(Consumer<LiveClientSettings> 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);
+    LiveClientBuilder addListener(Object listener);
 
 
     /**

API/src/main/java/io/github/jwdeveloper/tiktok/websocket/LiveSocketClient.java

@@ -24,9 +24,8 @@ package io.github.jwdeveloper.tiktok.websocket;
 
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
-import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 
-public interface SocketClient {
+public interface LiveSocketClient {
     void start(LiveConnectionData.Response webcastResponse, LiveClient tikTokLiveClient);
     void stop();
 }

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

@@ -36,7 +36,7 @@ import io.github.jwdeveloper.tiktok.listener.*;
 import io.github.jwdeveloper.tiktok.live.*;
 import io.github.jwdeveloper.tiktok.messages.webcast.WebcastResponse;
 import io.github.jwdeveloper.tiktok.models.ConnectionState;
-import io.github.jwdeveloper.tiktok.websocket.SocketClient;
+import io.github.jwdeveloper.tiktok.websocket.LiveSocketClient;
 import lombok.Getter;
 
 import java.util.Base64;
@@ -49,7 +49,7 @@ public class TikTokLiveClient implements LiveClient
 {
     private final TikTokRoomInfo roomInfo;
     private final LiveHttpClient httpClient;
-    private final SocketClient webSocketClient;
+    private final LiveSocketClient webSocketClient;
     private final LiveEventsHandler tikTokEventHandler;
     private final LiveClientSettings clientSettings;
     private final ListenersManager listenersManager;
@@ -62,7 +62,7 @@ public class TikTokLiveClient implements LiveClient
             GiftsManager giftsManager,
             TikTokRoomInfo tikTokLiveMeta,
             LiveHttpClient tiktokHttpClient,
-            SocketClient webSocketClient,
+            LiveSocketClient webSocketClient,
             LiveEventsHandler tikTokEventHandler,
             LiveClientSettings clientSettings,
             ListenersManager listenersManager,

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

@@ -52,7 +52,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
     protected final LiveClientSettings clientSettings;
     protected final LiveEventsHandler eventHandler;
-    protected final List<TikTokEventListener> listeners;
+    protected final List<Object> listeners;
     protected final List<Consumer<LiveMapper>> onCustomMappings;
     protected final List<Consumer<DependanceContainerBuilder>> onCustomDependencies;
 
@@ -75,7 +75,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         return this;
     }
 
-    public TikTokLiveClientBuilder addListener(TikTokEventListener listener) {
+    public TikTokLiveClientBuilder addListener(Object listener) {
         if (listener != null)
             listeners.add(listener);
         return this;
@@ -97,6 +97,7 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
         if (clientSettings.getHostName().startsWith("@"))
             clientSettings.setHostName(clientSettings.getHostName().substring(1));
 
+        //TODO 250 Magic number
         if (clientSettings.getPingInterval() < 250)
             throw new TikTokLiveException("Minimum allowed ping interval is 250 millseconds");
 
@@ -124,20 +125,23 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
 
         //messages
         dependance.registerSingleton(LiveEventsHandler.class, eventHandler);
-        dependance.registerSingleton(LiveMessagesHandler.class,TikTokLiveMessageHandler.class);
+        dependance.registerSingleton(LiveMessagesHandler.class, TikTokLiveMessageHandler.class);
 
         //listeners
-        dependance.registerSingletonList(TikTokEventListener.class, (e) -> listeners);
+        dependance.registerSingleton(ListenersManager.class, container ->
-        dependance.registerSingleton(ListenersManager.class, TikTokListenersManager.class);
+        {
+            var eventHandlers = (LiveEventsHandler) container.find(LiveEventsHandler.class);
+            return new TikTokListenersManager(listeners, eventHandlers);
+        });
 
         //networking
         dependance.registerSingleton(HttpClientFactory.class);
         dependance.registerSingleton(TikTokWebSocketPingingTask.class);
         if (clientSettings.isOffline()) {
-            dependance.registerSingleton(SocketClient.class, TikTokWebSocketOfflineClient.class);
+            dependance.registerSingleton(LiveSocketClient.class, TikTokWebSocketOfflineClient.class);
             dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpOfflineClient.class);
         } else {
-            dependance.registerSingleton(SocketClient.class, TikTokWebSocketClient.class);
+            dependance.registerSingleton(LiveSocketClient.class, TikTokWebSocketClient.class);
             dependance.registerSingleton(LiveHttpClient.class, TikTokLiveHttpClient.class);
         }
 

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

@@ -33,8 +33,7 @@ import java.util.Map;
 @Value
 public class ListenerBindingModel
 {
-
+    Object listener;
-    TikTokEventListener listener;
 
     Map<Class<?>, List<EventConsumer<?>>> events;
 }

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

@@ -23,7 +23,6 @@
 package io.github.jwdeveloper.tiktok.listener;
 
 
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
 import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
 import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokEventListenerMethodException;
@@ -32,30 +31,31 @@ import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
 import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
+import java.util.concurrent.ExecutorService;
-import java.util.HashMap;
+import java.util.concurrent.Executors;
-import java.util.List;
 
 public class TikTokListenersManager implements ListenersManager {
     private final LiveEventsHandler eventObserver;
     private final List<ListenerBindingModel> bindingModels;
+    private final ExecutorService executorService;
 
-    public TikTokListenersManager(List<TikTokEventListener> listeners, LiveEventsHandler tikTokEventHandler) {
+    public TikTokListenersManager(List<Object> listeners, LiveEventsHandler tikTokEventHandler) {
         this.eventObserver = tikTokEventHandler;
         this.bindingModels = new ArrayList<>(listeners.size());
         for (var listener : listeners) {
             addListener(listener);
         }
+        executorService = Executors.newFixedThreadPool(4);
     }
 
     @Override
-    public List<TikTokEventListener> getListeners() {
+    public List<Object> getListeners() {
         return bindingModels.stream().map(ListenerBindingModel::getListener).toList();
     }
 
     @Override
-    public void addListener(TikTokEventListener listener) {
+    public void addListener(Object listener) {
         var alreadyExists = bindingModels.stream().filter(e -> e.getListener() == listener).findAny();
         if (alreadyExists.isPresent()) {
             throw new TikTokLiveException("Listener " + listener.getClass() + " has already been registered");
@@ -72,7 +72,7 @@ public class TikTokListenersManager implements ListenersManager {
     }
 
     @Override
-    public void removeListener(TikTokEventListener listener) {
+    public void removeListener(Object listener) {
         var optional = bindingModels.stream().filter(e -> e.getListener() == listener).findAny();
         if (optional.isEmpty()) {
             return;
@@ -89,29 +89,41 @@ public class TikTokListenersManager implements ListenersManager {
         bindingModels.remove(optional.get());
     }
 
-    private ListenerBindingModel bindToEvents(TikTokEventListener listener) {
+    private ListenerBindingModel bindToEvents(Object listener) {
-
         var clazz = listener.getClass();
-        var methods = Arrays.stream(clazz.getDeclaredMethods()).filter(m ->
+        var methods = Arrays.stream(clazz.getDeclaredMethods())
-                m.getParameterCount() == 2 &&
+                .filter(m ->
-                        m.isAnnotationPresent(TikTokEventObserver.class)).toList();
+                        m.getParameterCount() >= 1 &&
+                                m.isAnnotationPresent(TikTokEventObserver.class))
+                .toList();
         var eventsMap = new HashMap<Class<?>, List<EventConsumer<?>>>();
         for (var method : methods) {
-            var liveclientClass = method.getParameterTypes()[0];
+            var annotation = method.getAnnotation(TikTokEventObserver.class);
-            var eventClass = method.getParameterTypes()[1];
+            var tiktokEventsParameters = Arrays.stream(method.getParameters())
-
+                    .filter(parameter ->
-            if (!LiveClient.class.isAssignableFrom(liveclientClass) && !liveclientClass.equals(LiveClient.class)) {
+                            TikTokEvent.class.isAssignableFrom(parameter.getType()) ||
-                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 1st parameter must be instance of " + LiveClient.class.getName()
+                                    parameter.getType().equals(TikTokEvent.class))
-                    + " | Invalid parameter class: "+liveclientClass.getName());
+                    .toList();
-            }
+            if (tiktokEventsParameters.size() != 1) {
-
+                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() must have only one parameter that inherits from class " + TikTokEvent.class.getName());
-            if (!TikTokEvent.class.isAssignableFrom(eventClass) && !eventClass.equals(TikTokEvent.class)) {
-                throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 2nd parameter must be instance of " + TikTokEvent.class.getName()
-                    + " | Invalid parameter class: "+eventClass.getName());
             }
 
+            var eventType = tiktokEventsParameters.get(0).getType();
             EventConsumer eventMethodRef = (liveClient, event) ->
             {
+                if (annotation.async()) {
+                    executorService.submit(() ->
+                    {
+                        try {
+                            method.setAccessible(true);
+                            method.invoke(listener, liveClient, event);
+                        } catch (Exception e) {
+                            throw new TikTokEventListenerMethodException(e);
+                        }
+                    });
+                    return;
+                }
+
                 try {
                     method.setAccessible(true);
                     method.invoke(listener, liveClient, event);
@@ -119,7 +131,7 @@ public class TikTokListenersManager implements ListenersManager {
                     throw new TikTokEventListenerMethodException(e);
                 }
             };
-            eventsMap.computeIfAbsent(eventClass, (a) -> new ArrayList<>()).add(eventMethodRef);
+            eventsMap.computeIfAbsent(eventType, (a) -> new ArrayList<>()).add(eventMethodRef);
         }
         return new ListenerBindingModel(listener, eventsMap);
     }

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

@@ -29,6 +29,9 @@ import io.github.jwdeveloper.tiktok.utils.ProtoBufferObject;
 import io.github.jwdeveloper.tiktok.utils.ProtocolUtils;
 
 public class TikTokLiveMapperHelper implements LiveMapperHelper {
+
+    private static final String PACKAGE_PREFIX = "io.github.jwdeveloper.tiktok.messages.webcast.";
+
     private final TikTokGenericEventMapper genericMapper;
 
     public TikTokLiveMapperHelper(TikTokGenericEventMapper genericMapper) {
@@ -39,6 +42,7 @@ public class TikTokLiveMapperHelper implements LiveMapperHelper {
     public <T extends GeneratedMessageV3> T bytesToWebcastObject(byte[] bytes, Class<T> messageClass) {
         try {
             var parsingMethod = genericMapper.getParsingMethod(messageClass);
+            //NULL is passed, since Parsing method is Static
             var sourceObject = parsingMethod.invoke(null, bytes);
             return (T) sourceObject;
         } catch (Exception e) {
@@ -49,7 +53,7 @@ public class TikTokLiveMapperHelper implements LiveMapperHelper {
     @Override
     public Object bytesToWebcastObject(byte[] bytes, String messageName) {
         try {
-            var packageName = "io.github.jwdeveloper.tiktok.messages.webcast." + messageName;
+            var packageName = PACKAGE_PREFIX + messageName;
             var clazz = Class.forName(packageName);
             return bytesToWebcastObject(bytes, (Class<? extends GeneratedMessageV3>) clazz);
         } catch (Exception e) {
@@ -60,7 +64,7 @@ public class TikTokLiveMapperHelper implements LiveMapperHelper {
     @Override
     public boolean isMessageHasProtoClass(String messageName) {
         try {
-            var packageName = "io.github.jwdeveloper.tiktok.messages.webcast." + messageName;
+            var packageName = PACKAGE_PREFIX + messageName;
             Class.forName(packageName);
             return true;
         } catch (Exception e) {

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

@@ -22,8 +22,6 @@
  */
 package io.github.jwdeveloper.tiktok.websocket;
 
-import io.github.jwdeveloper.dependance.injector.api.containers.Container;
-import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.dto.ProxyData;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.data.settings.*;
@@ -38,7 +36,7 @@ import java.net.Proxy;
 import java.security.cert.X509Certificate;
 import java.util.HashMap;
 
-public class TikTokWebSocketClient implements SocketClient {
+public class TikTokWebSocketClient implements LiveSocketClient {
     private final LiveClientSettings clientSettings;
     private final LiveMessagesHandler messageHandler;
     private final LiveEventsHandler tikTokEventHandler;

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

@@ -23,7 +23,6 @@
 package io.github.jwdeveloper.tiktok.websocket;
 
 import com.google.protobuf.ByteString;
-import io.github.jwdeveloper.tiktok.*;
 import io.github.jwdeveloper.tiktok.data.events.*;
 import io.github.jwdeveloper.tiktok.exceptions.TikTokProtocolBufferException;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
@@ -40,9 +39,9 @@ import java.util.*;
 
 public class TikTokWebSocketListener extends WebSocketClient {
 
-    private final LiveMessagesHandler messageHandler;
+    private final LiveMessagesHandler messagesHandler;
-    private final LiveEventsHandler tikTokEventHandler;
+    private final LiveEventsHandler eventHandler;
-    private final LiveClient tikTokLiveClient;
+    private final LiveClient liveClient;
 
     public TikTokWebSocketListener(URI serverUri,
                                    Map<String, String> httpHeaders,
@@ -51,9 +50,9 @@ public class TikTokWebSocketListener extends WebSocketClient {
                                    LiveEventsHandler tikTokEventHandler,
                                    LiveClient tikTokLiveClient) {
         super(serverUri, new Draft_6455(), httpHeaders, connectTimeout);
-        this.messageHandler = messageHandler;
+        this.messagesHandler = messageHandler;
-        this.tikTokEventHandler = tikTokEventHandler;
+        this.eventHandler = tikTokEventHandler;
-        this.tikTokLiveClient = tikTokLiveClient;
+        this.liveClient = tikTokLiveClient;
     }
 
     @Override
@@ -61,7 +60,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
         try {
             handleBinary(bytes.array());
         } catch (Exception e) {
-            tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(e));
+            eventHandler.publish(liveClient, new TikTokErrorEvent(e));
         }
         if (isOpen()) {
             sendPing();
@@ -85,12 +84,12 @@ public class TikTokWebSocketListener extends WebSocketClient {
                 this.send(pushFrameBuilder.build().toByteArray());
             }
         }
-        messageHandler.handle(tikTokLiveClient, webcastResponse);
+        messagesHandler.handle(liveClient, webcastResponse);
     }
 
     @Override
     public void onOpen(ServerHandshake serverHandshake) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokConnectedEvent());
+        eventHandler.publish(liveClient, new TikTokConnectedEvent());
         if (isOpen()) {
             sendPing();
         }
@@ -98,13 +97,13 @@ public class TikTokWebSocketListener extends WebSocketClient {
 
     @Override
     public void onClose(int code, String reason, boolean remote) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokDisconnectedEvent(reason));
+        eventHandler.publish(liveClient, new TikTokDisconnectedEvent(reason));
-        tikTokLiveClient.disconnect();
+        liveClient.disconnect();
     }
 
     @Override
     public void onError(Exception error) {
-        tikTokEventHandler.publish(tikTokLiveClient, new TikTokErrorEvent(error));
+        eventHandler.publish(liveClient, new TikTokErrorEvent(error));
         if (isOpen()) {
             sendPing();
         }
@@ -132,6 +131,7 @@ public class TikTokWebSocketListener extends WebSocketClient {
 
     @Override
     public void onMessage(String s) {
-        // System.err.println(s);
+        //TODO we are not using this method, however I wounder if there might be
+        //so messages that are send as String from TikTok, for example some Jsons
     }
 }

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

@@ -22,14 +22,13 @@
  */
 package io.github.jwdeveloper.tiktok.websocket;
 
-import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
 import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
 import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
 import io.github.jwdeveloper.tiktok.data.requests.LiveConnectionData;
 import io.github.jwdeveloper.tiktok.live.LiveClient;
 import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
 
-public class TikTokWebSocketOfflineClient implements SocketClient {
+public class TikTokWebSocketOfflineClient implements LiveSocketClient {
 
     private final LiveEventsHandler handler;
     private LiveClient liveClient;

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

@@ -23,6 +23,7 @@
 package io.github.jwdeveloper.tiktok.listener;
 
 import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
+import io.github.jwdeveloper.tiktok.annotations.Priority;
 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;
@@ -48,23 +49,23 @@ class TikTokListenersManagerTest {
     @BeforeEach
     void setUp() {
         eventObserver = Mockito.mock(TikTokLiveEventHandler.class);
-        List<TikTokEventListener> listeners = new ArrayList<>();
+        List<Object> listeners = new ArrayList<>();
         tikTokListenersManager = new TikTokListenersManager(listeners, eventObserver);
     }
 
     @Test
     void addListener() {
-        TikTokEventListener listener =new TikTokEventListenerTest();
+        Object listener =new TikTokEventListenerTest();
         tikTokListenersManager.addListener(listener);
 
-        List<TikTokEventListener> listeners = tikTokListenersManager.getListeners();
+        List<Object> listeners = tikTokListenersManager.getListeners();
         assertEquals(1, listeners.size());
         assertSame(listener, listeners.get(0));
     }
 
     @Test
     void addListener_alreadyRegistered_throwsException() {
-        TikTokEventListener listener = new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         tikTokListenersManager.addListener(listener);
 
         Exception exception = assertThrows(TikTokLiveException.class, () -> {
@@ -76,22 +77,22 @@ class TikTokListenersManagerTest {
 
     @Test
     void removeListener() {
-        TikTokEventListener listener = new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         tikTokListenersManager.addListener(listener);
         tikTokListenersManager.removeListener(listener);
 
-        List<TikTokEventListener> listeners = tikTokListenersManager.getListeners();
+        List<Object> listeners = tikTokListenersManager.getListeners();
         assertTrue(listeners.isEmpty());
     }
 
     @Test
     void removeListener_notRegistered_doesNotThrow() {
-        TikTokEventListener listener = new TikTokEventListenerTest();
+        Object listener = new TikTokEventListenerTest();
         assertDoesNotThrow(() -> tikTokListenersManager.removeListener(listener));
     }
 
 
-    public static class TikTokEventListenerTest implements TikTokEventListener
+    public static class TikTokEventListenerTest
     {
         @TikTokEventObserver
         public void onJoin(LiveClient client, TikTokJoinEvent joinEvent)
@@ -99,7 +100,7 @@ class TikTokListenersManagerTest {
 
         }
 
-        @TikTokEventObserver
+        @TikTokEventObserver(priority = Priority.NORMAL,async=true)
         public void onGift(LiveClient client, TikTokGiftEvent giftMessageEvent)
         {
 

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

@@ -29,8 +29,6 @@ public class GiftsExample {
     public static void main(String[] args) {
         var giftsManager = TikTokLive.gifts();
 
-
-
         var giftsList = giftsManager.toList();
         for (var gift : giftsList) {
             System.out.println("Gift: " + gift);