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

Merge pull request #89 from jwdeveloper/develop-1.8.2

Browse Source 
Develop 1.8.2
This commit is contained in:
Jacek W
2024-07-06 17:12:01 +02:00
committed by GitHub
parent 16cd819aaf b59373254c
commit 5b17c33236
45 changed files with 455 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
API/src/main/java/io/github/jwdeveloper/tiktok/annotations/Priority.java Normal file
View File

@@ -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 final int value;
Priority(int value) {
this.value = value;
}
}

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

@@ -28,5 +28,14 @@ import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
public @interface TikTokEventObserver
{
/**
* When more than one method listen for certain Event, you can specify the method priority
* @see Priority
*/
Priority priority() default Priority.NORMAL;
/**
* When true, action is invoked on a thread, from the threads pool
*/
boolean async() default false;
}

12
API/src/main/java/io/github/jwdeveloper/tiktok/data/events/TikTokLinkMicBattleEvent.java
View File

@@ -43,8 +43,6 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
true if battle is finished otherwise false
*/
private final boolean finished;
@Getter(AccessLevel.NONE)
private final boolean oneVsOne;
private final List<Team> teams;
public TikTokLinkMicBattleEvent(WebcastLinkMicBattle msg) {
@@ -55,7 +53,6 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
if (msg.getHostTeamCount() == 2) { // 1v1 battle
teams.add(new Team1v1(msg.getHostTeam(0), msg));
teams.add(new Team1v1(msg.getHostTeam(1), msg));
oneVsOne = true;
} else { // 2v2 battle
if (isFinished()) {
teams.add(new Team2v2(msg.getHostData2V2List().stream().filter(data -> data.getTeamNumber() == 1).findFirst().orElse(null), msg));
@@ -64,7 +61,6 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
teams.add(new Team2v2(msg.getHostTeam(0), msg.getHostTeam(1), msg));
teams.add(new Team2v2(msg.getHostTeam(2), msg.getHostTeam(3), msg));
}
oneVsOne = false;
}
// Info:
@@ -74,10 +70,14 @@ public class TikTokLinkMicBattleEvent extends TikTokHeaderEvent
}
public boolean is1v1() {
return oneVsOne;
return teams.get(0) instanceof Team1v1;
}
public boolean is2v2() {
return !oneVsOne;
return teams.get(0) instanceof Team2v2;
}
public boolean isTie() {
return isFinished() && teams.get(0).getTotalPoints() == teams.get(1).getTotalPoints();
}
}

5
API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Team.java
View File

@@ -22,7 +22,12 @@
*/
package io.github.jwdeveloper.tiktok.data.models.battles;
import lombok.Getter;
public abstract class Team {
/** Value >= 0 when finished otherwise -1 */
@Getter protected int totalPoints;
/**
* Provides a check for verifying if this team represents a 1v1 Team.
* @return true if this team is of type {@link Team1v1}, false otherwise.

5
API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Team1v1.java
View File

@@ -29,10 +29,7 @@ import lombok.Getter;
import java.util.*;
@Getter
public class Team1v1 extends Team
{
/** Value >= 0 when finished otherwise -1 */
private final int totalPoints;
public class Team1v1 extends Team {
private final int winStreak;
private final User host;
private final List<Viewer> viewers;

3
API/src/main/java/io/github/jwdeveloper/tiktok/data/models/battles/Team2v2.java
View File

@@ -30,9 +30,6 @@ import java.util.*;
@Getter
public class Team2v2 extends Team {
/** Value >= 0 when finished otherwise -1 */
private final int totalPoints;
private final List<User> hosts;
private final List<Viewer> viewers;

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

@@ -25,16 +25,13 @@ package io.github.jwdeveloper.tiktok.listener;
import java.util.List;
/**
* You can dynamically add or removing TikTokEventListener
*
* @see TikTokEventListener
*
* Manage events listeners objects
*/
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);
}

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

@@ -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 = "1.8.1 (This interface is not longer needed, please remove it from your class)")
public interface TikTokEventListener {
}

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

@@ -24,7 +24,6 @@ package io.github.jwdeveloper.tiktok.live.builder;
import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
import io.github.jwdeveloper.tiktok.data.settings.LiveClientSettings;
import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
import io.github.jwdeveloper.tiktok.live.LiveClient;
import io.github.jwdeveloper.tiktok.mappers.LiveMapper;
@@ -33,40 +32,43 @@ import java.util.function.Consumer;
public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
/**
* This method is triggered after default mappings are registered
* It could be used to OVERRIDE behaviour of mappings and implement custom behaviour
*
* <p>
* Be aware if for example you override WebcastGiftEvent, onGiftEvent() will not be working
*
* @param onCustomMappings lambda method
* @return
*/
LiveClientBuilder onMapping(Consumer<LiveMapper> onCustomMappings);
LiveClientBuilder mappings(Consumer<LiveMapper> onCustomMappings);
@Deprecated(forRemoval = true, since = "1.8.2 use `mappings` method instead")
LiveClientBuilder onMappings(Consumer<LiveMapper> onCustomMappings);
/**
* Configuration of client settings
* @see LiveClientSettings
*
* @param onConfigure
* @return
* @see LiveClientSettings
*/
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);
/**
* Allows you to use own implementation of internal TikTokLive dependencies,
* when the default implementation does not meet your needs
*
*
* @param onCustomizeDependencies access to dependency container
* @return
*/
@@ -74,18 +76,19 @@ public interface LiveClientBuilder extends EventsBuilder<LiveClientBuilder> {
/**
* Builds new instance of the LiveClient
*
* @return LiveClient object
*/
LiveClient build();
/**
* Builds new instance of the LiveClient and connects to live
*
* @return LiveClient object
*/
LiveClient buildAndConnect();
/**
*
* @return LiveClient object and connects to TikTok live asynchronously
*/
CompletableFuture<LiveClient> buildAndConnectAsync();

3
API/src/main/java/io/github/jwdeveloper/tiktok/websocket/SocketClient.java → API/src/main/java/io/github/jwdeveloper/tiktok/websocket/LiveSocketClient.java
View File

@@ -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();
}

28
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,
@@ -78,17 +78,6 @@ public class TikTokLiveClient implements LiveClient
this.logger = logger;
}
public void connectAsync(Consumer<LiveClient> onConnection) {
connectAsync().thenAccept(onConnection);
}
public CompletableFuture<LiveClient> connectAsync() {
return CompletableFuture.supplyAsync(() -> {
connect();
return this;
});
}
public void connect() {
try {
tryConnect();
@@ -199,4 +188,15 @@ public class TikTokLiveClient implements LiveClient
messageHandler.handleSingleMessage(this, message);
}
public void connectAsync(Consumer<LiveClient> onConnection) {
connectAsync().thenAccept(onConnection);
}
public CompletableFuture<LiveClient> connectAsync() {
return CompletableFuture.supplyAsync(() -> {
connect();
return this;
});
}
}

24
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;
@@ -65,17 +65,23 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
this.onCustomDependencies = new ArrayList<>();
}
public LiveClientBuilder onMapping(Consumer<LiveMapper> consumer) {
public LiveClientBuilder mappings(Consumer<LiveMapper> consumer) {
this.onCustomMappings.add(consumer);
return this;
}
@Override
public LiveClientBuilder onMappings(Consumer<LiveMapper> onCustomMappings) {
mappings(onCustomMappings);
return this;
}
public TikTokLiveClientBuilder configure(Consumer<LiveClientSettings> onConfigure) {
onConfigure.accept(clientSettings);
return this;
}
public TikTokLiveClientBuilder addListener(TikTokEventListener listener) {
public TikTokLiveClientBuilder addListener(Object listener) {
if (listener != null)
listeners.add(listener);
return this;
@@ -97,8 +103,9 @@ 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");
throw new TikTokLiveException("Minimum allowed ping interval is 250 milliseconds");
var httpSettings = clientSettings.getHttpSettings();
httpSettings.getParams().put("app_language", clientSettings.getClientLanguage());
@@ -127,17 +134,16 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
dependance.registerSingleton(LiveMessagesHandler.class, TikTokLiveMessageHandler.class);
//listeners
dependance.registerSingletonList(TikTokEventListener.class, (e) -> listeners);
dependance.registerSingleton(ListenersManager.class, TikTokListenersManager.class);
//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);
}
@@ -176,8 +182,10 @@ public class TikTokLiveClientBuilder implements LiveClientBuilder {
dependance.registerSingleton(LiveClient.class, TikTokLiveClient.class);
onCustomDependencies.forEach(action -> action.accept(dependance));
var container = dependance.build();
var listenerManager = container.find(ListenersManager.class);
listeners.forEach(listenerManager::addListener);
return container.find(LiveClient.class);
}

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

@@ -136,7 +136,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
var url = TIKTOK_URL_WEB + "api-live/user/room";
var result = httpFactory.client(url)
.withParam("uniqueId", request.getUserName())
.withParam("sourceType", "54")
.withParam("sourceType", "54") //MAGIC NUMBER, WHAT 54 means?
.build()
.toJsonResponse();
@@ -218,7 +218,7 @@ public class TikTokLiveHttpClient implements LiveHttpClient
private ActionResult<HttpResponse<byte[]>> getByteResponse(String room_id) {
HttpClientBuilder builder = httpFactory.client(TIKTOK_SIGN_API)
.withParam("client", "ttlive-java")
.withParam("uuc", "1")
.withParam("uuc", "1") //MAGIC NUMBER!
.withParam("room_id", room_id);
if (clientSettings.getApiKey() != null)

25
Client/src/main/java/io/github/jwdeveloper/tiktok/listener/ListenerBindingModel.java → Client/src/main/java/io/github/jwdeveloper/tiktok/listener/ListenerMethodInfo.java
View File

@@ -22,19 +22,26 @@
*/
package io.github.jwdeveloper.tiktok.listener;
import io.github.jwdeveloper.tiktok.annotations.Priority;
import io.github.jwdeveloper.tiktok.live.builder.EventConsumer;
import lombok.Data;
import lombok.Value;
import java.util.List;
import java.util.Map;
import java.lang.reflect.Method;
@Value
public class ListenerBindingModel
{
@Data
public class ListenerMethodInfo {
private Object listener;
TikTokEventListener listener;
private Class eventType;
Map<Class<?>, List<EventConsumer<?>>> events;
private Method method;
private Priority priority;
private boolean async;
private EventConsumer action = (a, b) -> {
};
}

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

@@ -23,104 +23,135 @@
package io.github.jwdeveloper.tiktok.listener;
import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
import io.github.jwdeveloper.dependance.api.DependanceContainer;
import io.github.jwdeveloper.tiktok.annotations.TikTokEventObserver;
import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
import io.github.jwdeveloper.tiktok.exceptions.TikTokEventListenerMethodException;
import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
import io.github.jwdeveloper.tiktok.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.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
public class TikTokListenersManager implements ListenersManager {
private final LiveEventsHandler eventObserver;
private final List<ListenerBindingModel> bindingModels;
public TikTokListenersManager(List<TikTokEventListener> listeners, LiveEventsHandler tikTokEventHandler) {
this.eventObserver = tikTokEventHandler;
this.bindingModels = new ArrayList<>(listeners.size());
for (var listener : listeners) {
addListener(listener);
}
private final Map<Object, List<ListenerMethodInfo>> listeners;
private final LiveEventsHandler eventsHandler;
private final ExecutorService executorService;
private final DependanceContainer dependanceContainer;
public TikTokListenersManager(LiveEventsHandler tikTokEventHandler,
DependanceContainer dependanceContainer) {
this.eventsHandler = tikTokEventHandler;
this.dependanceContainer = dependanceContainer;
this.listeners = new HashMap<>();
executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
}
@Override
public List<TikTokEventListener> getListeners() {
return bindingModels.stream().map(ListenerBindingModel::getListener).toList();
public List<Object> getListeners() {
return listeners.keySet().stream().toList();
}
@Override
public void addListener(TikTokEventListener listener) {
var alreadyExists = bindingModels.stream().filter(e -> e.getListener() == listener).findAny();
if (alreadyExists.isPresent()) {
public void addListener(Object listener) {
if (listeners.containsKey(listener)) {
throw new TikTokLiveException("Listener " + listener.getClass() + " has already been registered");
}
var bindingModel = bindToEvents(listener);
for (var eventEntrySet : bindingModel.getEvents().entrySet()) {
var eventType = eventEntrySet.getKey();
for (var methods : eventEntrySet.getValue()) {
eventObserver.subscribe(eventType, methods);
var methodsInfo = getMethodsInfo(listener);
for (var methodInfo : methodsInfo) {
eventsHandler.subscribe(methodInfo.getEventType(), methodInfo.getAction());
}
}
bindingModels.add(bindingModel);
listeners.put(listener, methodsInfo);
}
@Override
public void removeListener(TikTokEventListener listener) {
var optional = bindingModels.stream().filter(e -> e.getListener() == listener).findAny();
if (optional.isEmpty()) {
public void removeListener(Object listener) {
if (!listeners.containsKey(listener)) {
return;
}
var bindingModel = optional.get();
for (var eventEntrySet : bindingModel.getEvents().entrySet()) {
var eventType = eventEntrySet.getKey();
for (var methods : eventEntrySet.getValue()) {
eventObserver.unsubscribe(eventType, methods);
var methodsInfo = listeners.get(listener);
for (var methodInfo : methodsInfo) {
eventsHandler.unsubscribe(methodInfo.getEventType(), methodInfo.getAction());
}
}
bindingModels.remove(optional.get());
listeners.remove(listener);
}
private ListenerBindingModel bindToEvents(TikTokEventListener listener) {
var clazz = listener.getClass();
var methods = Arrays.stream(clazz.getDeclaredMethods()).filter(m ->
m.getParameterCount() == 2 &&
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());
private List<ListenerMethodInfo> getMethodsInfo(Object listener) {
return Arrays.stream(listener.getClass().getDeclaredMethods())
.filter(e -> e.isAnnotationPresent(TikTokEventObserver.class))
.filter(e -> e.getParameterCount() >= 1)
.map(method -> getSingleMethodInfo(listener, method))
.sorted(Comparator.comparingInt(a -> a.getPriority().value))
.toList();
}
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());
private ListenerMethodInfo getSingleMethodInfo(Object listener, Method method) {
method.setAccessible(true);
var annotation = method.getAnnotation(TikTokEventObserver.class);
var tiktokEventType = Arrays.stream(method.getParameterTypes())
.filter(TikTokEvent.class::isAssignableFrom)
.findFirst()
.orElseThrow(() -> new TikTokEventListenerMethodException("Method " + method.getName() + "() must have only one parameter that inherits from class " + TikTokEvent.class.getName()));
var info = new ListenerMethodInfo();
info.setListener(listener);
info.setAsync(annotation.async());
info.setPriority(annotation.priority());
info.setEventType(tiktokEventType);
info.setAction(createAction(listener, method, tiktokEventType));
if (info.isAsync()) {
var action = info.getAction();
info.setAction((liveClient, event) ->
{
executorService.submit(() ->
{
action.onEvent(liveClient, event);
});
});
}
return info;
}
EventConsumer eventMethodRef = (liveClient, event) ->
//I know, implementation of this might look complicated
private EventConsumer createAction(Object listener, Method method, Class tiktokEventType) {
AtomicReference<Object> eventObjectRef = new AtomicReference<>();
var methodContainer = dependanceContainer.createChildContainer()
.configure(configuration ->
{
//Modifying container, so it returns TikTokEvent object instance,
//when TikTokEvent type is encountered in the methods parameters
configuration.onInjection(injectionEvent ->
{
if (injectionEvent.input().isAssignableFrom(tiktokEventType)) {
return eventObjectRef.get();
}
return injectionEvent.output();
});
})
.build();
return (liveClient, event) ->
{
try {
method.setAccessible(true);
method.invoke(listener, liveClient, event);
eventObjectRef.set(event);
//Creating list of input objects based on method parameters
//Objects are received from container
var parameters = methodContainer.resolveParameters(method);
method.invoke(listener, parameters);
} catch (Exception e) {
throw new TikTokEventListenerMethodException(e);
eventsHandler.publish(liveClient, new TikTokErrorEvent(new TikTokEventListenerMethodException(e)));
}
};
eventsMap.computeIfAbsent(eventClass, (a) -> new ArrayList<>()).add(eventMethodRef);
}
return new ListenerBindingModel(listener, eventsMap);
}
}

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

@@ -53,7 +53,7 @@ public class TikTokGenericEventMapper {
private final Map<Class<?>, Method> methodCache;
private final Map<TypePair, Constructor<?>> constructorCache;
private static final String PARSE_FIELD = "parseFrom";
public TikTokGenericEventMapper() {
this.methodCache = new HashMap<>();
this.constructorCache = new HashMap<>();
@@ -75,7 +75,7 @@ public class TikTokGenericEventMapper {
public Method getParsingMethod(Class<?> input) throws RuntimeException {
return methodCache.computeIfAbsent(input, aClass -> {
try {
return aClass.getDeclaredMethod("parseFrom", byte[].class);
return aClass.getDeclaredMethod(PARSE_FIELD, byte[].class);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}

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

@@ -34,11 +34,12 @@ public class TikTokLiveMapper implements LiveMapper {
private final Map<String, TikTokLiveMapperModel> mappers;
private final LiveMapperHelper mapperUtils;
private final TikTokLiveMapperModel globalMapperModel;
private static final String GLOBAL_MESSAGE = "GLOBAL MESSAGE";
public TikTokLiveMapper(LiveMapperHelper mapperUtils) {
this.mappers = new HashMap<>();
this.mapperUtils = mapperUtils;
this.globalMapperModel = new TikTokLiveMapperModel("any message");
this.globalMapperModel = new TikTokLiveMapperModel(GLOBAL_MESSAGE);
}
@Override

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

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

@@ -38,7 +38,6 @@ import java.util.*;
public class TikTokGiftEventHandler {
private final Map<Long, WebcastGiftMessage> giftsMessages;
private final TikTokRoomInfo tikTokRoomInfo;
private final GiftsManager giftsManager;
public TikTokGiftEventHandler(GiftsManager giftsManager, TikTokRoomInfo tikTokRoomInfo) {

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;

51
Client/src/test/java/io/github/jwdeveloper/tiktok/TikTokLiveClientTests.java Normal file
View File

@@ -0,0 +1,51 @@
package io.github.jwdeveloper.tiktok;
import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
import io.github.jwdeveloper.tiktok.data.events.TikTokConnectedEvent;
import io.github.jwdeveloper.tiktok.data.events.TikTokDisconnectedEvent;
import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
import io.github.jwdeveloper.tiktok.data.events.control.TikTokConnectingEvent;
import io.github.jwdeveloper.tiktok.data.events.control.TikTokPreConnectionEvent;
import io.github.jwdeveloper.tiktok.data.events.http.TikTokRoomDataResponseEvent;
import io.github.jwdeveloper.tiktok.data.events.room.TikTokRoomInfoEvent;
import io.github.jwdeveloper.tiktok.exceptions.TikTokLiveException;
import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
import io.github.jwdeveloper.tiktok.models.ConnectionState;
import org.junit.Assert;
import org.junit.Test;
public class TikTokLiveClientTests extends TikTokTestBase {
@Override
public void onBeforeEachTest(LiveClientBuilder liveClientBuilder,
DependanceContainerBuilder containerBuilder) {
}
@Test
public void shouldThrownWhenAlreadyConnected() {
roomInfoMock().setConnectionState(ConnectionState.CONNECTED);
Assert.assertThrows(TikTokLiveException.class, () ->
{
liveClient().connect();
});
Assert.assertEquals(ConnectionState.DISCONNECTED, roomInfoMock().getConnectionState());
AssertEvents(
TikTokErrorEvent.class,
TikTokDisconnectedEvent.class
);
}
@Test
public void shouldConnect() {
liveClient().connect();
Assert.assertEquals(ConnectionState.CONNECTED, roomInfoMock().getConnectionState());
AssertEvents(
TikTokConnectingEvent.class,
TikTokRoomDataResponseEvent.class,
TikTokPreConnectionEvent.class,
TikTokConnectedEvent.class,
TikTokRoomInfoEvent.class);
}
}

53
Client/src/test/java/io/github/jwdeveloper/tiktok/TikTokTestBase.java Normal file
View File

@@ -0,0 +1,53 @@
package io.github.jwdeveloper.tiktok;
import io.github.jwdeveloper.dependance.implementation.DependanceContainerBuilder;
import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
import io.github.jwdeveloper.tiktok.live.LiveClient;
import io.github.jwdeveloper.tiktok.live.LiveEventsHandler;
import io.github.jwdeveloper.tiktok.live.builder.LiveClientBuilder;
import io.github.jwdeveloper.tiktok.mocks.EventsHandlerMock;
import lombok.Getter;
import lombok.experimental.Accessors;
import org.junit.Before;
/**
* Base class for the unit tests
*/
@Getter
@Accessors(fluent = true)
public abstract class TikTokTestBase {
private LiveClient liveClient;
private EventsHandlerMock eventsHandlerMock;
private TikTokRoomInfo roomInfoMock;
public void AssertEvents(Class<? extends TikTokEvent>... events) {
eventsHandlerMock.assertEvents(events);
}
@Before
public void setup() {
var builder = TikTokLive.newClient("test");
eventsHandlerMock = new EventsHandlerMock();
roomInfoMock = new TikTokRoomInfo();
roomInfoMock.setHostName("test");
liveClient = builder
.configure(liveClientSettings ->
{
liveClientSettings.setOffline(true);
liveClientSettings.setFetchGifts(false);
})
.customize(containerBuilder ->
{
containerBuilder.registerSingleton(LiveEventsHandler.class, eventsHandlerMock);
containerBuilder.registerSingleton(TikTokRoomInfo.class, roomInfoMock);
onBeforeEachTest(builder, containerBuilder);
}).build();
}
public abstract void onBeforeEachTest(LiveClientBuilder liveClientBuilder, DependanceContainerBuilder containerBuilder);
}

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

@@ -22,7 +22,10 @@
*/
package io.github.jwdeveloper.tiktok.listener;
import io.github.jwdeveloper.dependance.Dependance;
import io.github.jwdeveloper.dependance.api.DependanceContainer;
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;
@@ -44,27 +47,34 @@ class TikTokListenersManagerTest {
private TikTokLiveEventHandler eventObserver;
private TikTokListenersManager tikTokListenersManager;
private DependanceContainer dependanceContainer;
private LiveClient liveClient;
@BeforeEach
void setUp() {
eventObserver = Mockito.mock(TikTokLiveEventHandler.class);
List<TikTokEventListener> listeners = new ArrayList<>();
tikTokListenersManager = new TikTokListenersManager(listeners, eventObserver);
liveClient = Mockito.mock(LiveClient.class);
eventObserver = new TikTokLiveEventHandler();
dependanceContainer = Dependance.newContainer()
.registerSingleton(LiveClient.class, liveClient)
.build();
tikTokListenersManager = new TikTokListenersManager(eventObserver, dependanceContainer);
}
@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,39 +86,56 @@ 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
public void shouldTriggerEvents() {
Object listener = new TikTokEventListenerTest();
tikTokListenersManager.addListener(listener);
var fakeGiftEvent = TikTokGiftEvent.of("TestRosa", 1, 1);
eventObserver.publish(liveClient, fakeGiftEvent);
}
@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)
{
public void onJoin(LiveClient client, TikTokJoinEvent joinEvent) {
System.out.println("Hello from on join" + client + " " + joinEvent);
}
@TikTokEventObserver
public void onGift(LiveClient client, TikTokGiftEvent giftMessageEvent)
{
@TikTokEventObserver(priority = Priority.LOWEST)
public void onGift(LiveClient client, TikTokGiftEvent giftMessageEvent) {
System.out.println("Hello from onGift lowest priority" + client + " " + giftMessageEvent);
}
@TikTokEventObserver
public void onEvent(LiveClient client, TikTokEvent event)
{
@TikTokEventObserver(priority = Priority.NORMAL)
public void onGift2(LiveClient client, TikTokGiftEvent giftMessageEvent) {
System.out.println("Hello from onGift normal priority " + client + " " + giftMessageEvent);
}
@TikTokEventObserver(priority = Priority.HIGHEST)
public void onGift3(LiveClient client, TikTokGiftEvent giftMessageEvent) {
System.out.println("Hello from onGift highest priority " + client + " " + giftMessageEvent);
}
@TikTokEventObserver(async = true)
public void onEvent(LiveClient client, TikTokEvent event) {
System.out.println("Hello from onEvent im running on the thread " + Thread.currentThread().getName());
}
}
}

46
Client/src/test/java/io/github/jwdeveloper/tiktok/mocks/EventsHandlerMock.java Normal file
View File

@@ -0,0 +1,46 @@
package io.github.jwdeveloper.tiktok.mocks;
import io.github.jwdeveloper.tiktok.TikTokLiveEventHandler;
import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
import io.github.jwdeveloper.tiktok.live.LiveClient;
import java.util.ArrayList;
import java.util.List;
/**
* Cache published events,
*/
public class EventsHandlerMock extends TikTokLiveEventHandler {
private final List<TikTokEvent> publishedEvents = new ArrayList<TikTokEvent>();
@Override
public void publish(LiveClient tikTokLiveClient, TikTokEvent tikTokEvent) {
super.publish(tikTokLiveClient, tikTokEvent);
publishedEvents.add(tikTokEvent);
}
@SafeVarargs
public final void assertEvents(Class<? extends TikTokEvent>... events) {
if (events.length == 0 && !publishedEvents.isEmpty()) {
var classNames = publishedEvents.stream()
.map(e -> e.getClass().getSimpleName())
.toList();
var invokedEvents = String.join("\n", classNames);
throw new IllegalArgumentException("Not events should be invoked but there was: \n" + invokedEvents);
}
for (var i = 0; i < events.length; i++) {
var expectedEvent = events[i];
var invokedEvent = publishedEvents.get(i);
if (expectedEvent.equals(invokedEvent.getClass())) {
continue;
}
throw new RuntimeException("Expected event was " + expectedEvent + " but acctuall was " + invokedEvent.getClass());
}
}
}

2
Examples/pom.xml → examples/pom.xml
View File

@@ -46,7 +46,7 @@
<modelVersion>4.0.0</modelVersion>
<artifactId>Examples</artifactId>
<artifactId>examples</artifactId>
<dependencies>
<dependency>
<groupId>io.github.jwdeveloper.tiktok</groupId>

0
Examples/src/main/java/io/github/jwdeveloper/tiktok/CollectorExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/CollectorExample.java
View File

3
Examples/src/main/java/io/github/jwdeveloper/tiktok/ConnectionExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/ConnectionExample.java
View File

@@ -37,9 +37,6 @@ public class ConnectionExample {
public static void main(String[] args) throws IOException {
showLogo();
var gifts = TikTokLive.gifts();
TikTokLive.newClient(ConnectionExample.TIKTOK_HOSTNAME)
.configure(clientSettings ->
{

0
Examples/src/main/java/io/github/jwdeveloper/tiktok/CustomEventExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/CustomEventExample.java
View File

3
Examples/src/main/java/io/github/jwdeveloper/tiktok/CustomMappingExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/CustomMappingExample.java
View File

@@ -30,7 +30,7 @@ public class CustomMappingExample {
public static void main(String[] args) {
TikTokLive.newClient("saszareznikow")
.onMapping(mapper ->
.mappings(mapper ->
{
mapper.forMessage(WebcastChatMessage.class)
.onBeforeMapping((inputBytes, messageName, mapperHelper) ->
@@ -56,7 +56,6 @@ public class CustomMappingExample {
System.out.println("onAfter mapping, " + source.getClass().getSimpleName() + " was mapped to " + events.size() + " events");
return events;
});
/*
There might be cast that we don't have Webcast class for incoming message from TikTok
`mapperHelper.bytesToProtoBufferStructure` but you can still investigate message structure

0
Examples/src/main/java/io/github/jwdeveloper/tiktok/CustomizationExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/CustomizationExample.java
View File

0
Examples/src/main/java/io/github/jwdeveloper/tiktok/Events_And_Gifts_Testing_Example.java → examples/src/main/java/io/github/jwdeveloper/tiktok/Events_And_Gifts_Testing_Example.java
View File

2
Examples/src/main/java/io/github/jwdeveloper/tiktok/GiftsExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/GiftsExample.java
View File

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

23
Examples/src/main/java/io/github/jwdeveloper/tiktok/ListenerExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/ListenerExample.java
View File

@@ -28,21 +28,18 @@ import io.github.jwdeveloper.tiktok.data.events.TikTokErrorEvent;
import io.github.jwdeveloper.tiktok.data.events.common.TikTokEvent;
import io.github.jwdeveloper.tiktok.data.events.gift.TikTokGiftEvent;
import io.github.jwdeveloper.tiktok.data.events.social.TikTokLikeEvent;
import io.github.jwdeveloper.tiktok.listener.TikTokEventListener;
import io.github.jwdeveloper.tiktok.live.LiveClient;
import io.github.jwdeveloper.tiktok.utils.ConsoleColors;
import java.io.IOException;
public class ListenerExample
{
public class ListenerExample {
// <code>
/**
*
* Listeners are an alternative way of handling events.
* I would to suggest to use then when logic of handing event
* is more complex
*
*/
public static void main(String[] args) throws IOException {
showLogo();
@@ -55,23 +52,20 @@ public class ListenerExample
}
/**
*
* Method in TikTokEventListener should meet 4 requirements to be detected
* Method must meet 2 requirements to be detected
* - must have @TikTokEventObserver annotation
* - must have 2 parameters
* - first parameter must be LiveClient
* - second must be class that extending TikTokEvent
* - must have 1 parameter of type that extending TikTokEvent
*/
public static class CustomListener implements TikTokEventListener {
public static class CustomListener {
@TikTokEventObserver
public void onLike(LiveClient liveClient, TikTokLikeEvent event) {
public void onLike(TikTokLikeEvent event) {
System.out.println(event.toString());
}
@TikTokEventObserver
public void onError(LiveClient liveClient, TikTokErrorEvent event) {
public void onError(TikTokErrorEvent event, LiveClient liveClient) {
// event.getException().printStackTrace();
}
@@ -103,8 +97,7 @@ public class ListenerExample
}
// </code>
private static void showLogo()
{
private static void showLogo() {
System.out.println(ConsoleColors.GREEN + """
_____ _ _ _____ _ _ _ \s

0
Examples/src/main/java/io/github/jwdeveloper/tiktok/ProxyExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/ProxyExample.java
View File

1
Examples/src/main/java/io/github/jwdeveloper/tiktok/RecorderExample.java → examples/src/main/java/io/github/jwdeveloper/tiktok/RecorderExample.java
View File

@@ -32,6 +32,7 @@ public class RecorderExample {
public static void main(String[] args) {
TikTokLive.newClient("bangbetmenygy")
.configure(liveClientSettings ->
{

7
future.md Normal file
View File

@@ -0,0 +1,7 @@
Future plans:
[ ] Publish project to Maven repository instead of JITPACK
[ ] Dynamically generates readme.md when new version is released
[ ] Covers all possible classes from Client module with unit test
[ ] Add tests check to GitHub publish action
[ ] Generates documentation based on API module and publish it with GitHub pages

2
pom.xml
View File

@@ -11,7 +11,7 @@
<modules>
<module>API</module>
<module>Client</module>
<module>Examples</module>
<module>examples</module>
<module>tools-readme</module>
<module>extension-recorder</module>

6
tools-readme/pom.xml
View File

@@ -34,12 +34,6 @@
<version>2.13.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.github.jwdeveloper.Descrabble</groupId>
<artifactId>Descrabble-Full</artifactId>
<version>0.0.11-Release</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>

17
tools-readme/src/main/java/io/github/jwdeveloper/tiktok/EventsDecorator.java
View File

@@ -1,17 +0,0 @@
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)
{
}
}

1
tools-readme/src/main/java/io/github/jwdeveloper/tiktok/EventsInfoGenerator.java
View File

@@ -41,7 +41,6 @@ public class EventsInfoGenerator {
System.out.println(res);
}
public String run() {
var events = getEventsDtos();
var builder = new StringBuilder();

14
tools-readme/src/main/java/io/github/jwdeveloper/tiktok/Main.java
View File

@@ -1,8 +1,6 @@
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;
@@ -23,16 +21,6 @@ public class Main
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();
}
}

1
tools-readme/src/main/java/io/github/jwdeveloper/tiktok/ReadmeGenerator.java
View File

@@ -27,7 +27,6 @@ public class ReadmeGenerator {
public static void main(String[] args) {
var generator = new ReadmeGenerator();
generator.generate();
}
public void generate() {

3
tools-readme/src/main/resources/template.md
View File

@@ -88,8 +88,6 @@ Do you prefer other programming languages?
{{if item is 2}}
my name is {{item.name}}
{{else}}
{{end}}
@@ -98,7 +96,6 @@ my name is {{item.name}}
<br>
## Listeners
```java
{{listener-content}}
```