Smartcraft-Media-Tech/TikTokLiveJava
1
0
Fork 0
mirror of https://github.com/jwdeveloper/TikTokLiveJava.git synced 2026-02-27 16:59:39 -05:00
Code Issues Packages Projects Releases Wiki Activity

Improvement of Listener

Browse Source
This commit is contained in:
jacek.wolniewicz
2024-07-03 22:27:15 +02:00
parent 7005f58edd
commit 660cb287e9
16 changed files with 121 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClient.java
View File

@@ -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,

18
Client/src/main/java/io/github/jwdeveloper/tiktok/TikTokLiveClientBuilder.java
View File

@@ -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, TikTokListenersManager.class);
dependance.registerSingleton(ListenersManager.class, container ->
{
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);
}

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

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

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

@@ -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.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
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 ->
m.getParameterCount() == 2 &&
m.isAnnotationPresent(TikTokEventObserver.class)).toList();
var methods = Arrays.stream(clazz.getDeclaredMethods())
.filter(m ->
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 eventClass = method.getParameterTypes()[1];
if (!LiveClient.class.isAssignableFrom(liveclientClass) && !liveclientClass.equals(LiveClient.class)) {
throw new TikTokEventListenerMethodException("Method " + method.getName() + "() 1st parameter must be instance of " + LiveClient.class.getName()
+ " | Invalid parameter class: "+liveclientClass.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 annotation = method.getAnnotation(TikTokEventObserver.class);
var tiktokEventsParameters = Arrays.stream(method.getParameters())
.filter(parameter ->
TikTokEvent.class.isAssignableFrom(parameter.getType()) ||
parameter.getType().equals(TikTokEvent.class))
.toList();
if (tiktokEventsParameters.size() != 1) {
throw new TikTokEventListenerMethodException("Method " + method.getName() + "() must have only one parameter that inherits from class " + TikTokEvent.class.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);
}

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

@@ -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) {

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

@@ -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;

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

@@ -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 LiveEventsHandler tikTokEventHandler;
private final LiveClient tikTokLiveClient;
private final LiveMessagesHandler messagesHandler;
private final LiveEventsHandler eventHandler;
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.tikTokEventHandler = tikTokEventHandler;
this.tikTokLiveClient = tikTokLiveClient;
this.messagesHandler = messageHandler;
this.eventHandler = tikTokEventHandler;
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));
tikTokLiveClient.disconnect();
eventHandler.publish(liveClient, new TikTokDisconnectedEvent(reason));
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
}
}

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

@@ -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;

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

@@ -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)
{