More awesome event stuff and redemption event fix.

Author: TheLimeGlass

src/main/java/me/limeglass/streamelements/api/StreamElementsBuilder.java

@@ -8,6 +8,7 @@ public final class StreamElementsBuilder {
 	private String token, accountID;
 	private int timeout = 20 * 1000;
 	private Class<?>[] listeners;
+	private String[] emitters;
 
 	/**
 	 * For those whom love keeping clean methods per line.
@@ -38,6 +39,15 @@ public StreamElementsBuilder registerListeners(Class<?>... listeners) {
 		return this;
 	}
 
+	/**
+	 * Register any emitters you want.
+	 * The parameter string is the class path of the emitter. Example: me.limeglass.streamelements.internal.events.emitters
+	 */
+	public StreamElementsBuilder registerEmitters(String... emitters) {
+		this.emitters = emitters;
+		return this;
+	}
+	
 	/**
 	 * Set the connection timeout of the client.
 	 * Recommended to set one.
@@ -97,7 +107,7 @@ public int getTimeout() {
 	public StreamElements build() {
 		if (token == null || accountID == null)
 			throw new StreamElementsException("The StreamElements token or account ID was not set!");
-		return new StreamElementsClient(token, accountID, timeout, listeners);
+		return new StreamElementsClient(token, accountID, timeout, listeners, emitters);
 	}
 
 }

src/main/java/me/limeglass/streamelements/api/events/EmitterRegisterEvent.java

@@ -0,0 +1,43 @@
+package me.limeglass.streamelements.api.events;
+
+import me.limeglass.streamelements.internals.dummy.Cancellable;
+import me.limeglass.streamelements.internals.events.ElementsEvent;
+import me.limeglass.streamelements.internals.events.emitters.ElementsEmitter;
+
+public class EmitterRegisterEvent extends ElementsEvent implements Cancellable {
+	
+	private final ElementsEmitter emitter;
+	private boolean cancelled = false;
+
+	/**
+	 * Called when an emitter gets registered.
+	 */
+	public EmitterRegisterEvent(ElementsEmitter emitter) {
+		this.emitter = emitter;
+	}
+
+	/**
+	 * @return The emitter involved in the registering event.
+	 */
+	public ElementsEmitter getEmitter() {
+		return emitter;
+	}
+	
+	/**
+	 * Cancels the event.
+	 * @param cancel If the event should be cancelled or not.
+	 */
+	@Override
+	public void setCancelled(boolean cancel) {
+		this.cancelled = cancel;
+	}
+
+	/**
+	 * @return Checks if the event is cancelled or not.
+	 */
+	@Override
+	public boolean isCancelled() {
+		return cancelled;
+	}
+	
+}

src/main/java/me/limeglass/streamelements/api/events/RedemptionEvent.java

@@ -2,43 +2,80 @@
 
 import java.time.Instant;
 
-import me.limeglass.streamelements.api.objects.User;
+import me.limeglass.streamelements.internals.events.emitters.types.RedemptionEmitter.EventAlert;
+import me.limeglass.streamelements.internals.events.emitters.types.RedemptionEmitter.Redeemer;
+import me.limeglass.streamelements.internals.events.emitters.types.RedemptionEmitter.RedemptionItem;
 
 public class RedemptionEvent extends ActivityEvent {
-	
-	private final String redemption;
-	private final Number amount;
-	private final User user;
+
+	private final String ID, redeemerType;
+	private final RedemptionItem item;
+	private final Redeemer redeemer;
+	private final boolean completed;
+	private final EventAlert alert;
+	private final Instant updated;
 
 	/**
 	 * Called when someone uses a redemption.
 	 */
-	public RedemptionEvent(String type, Instant instant, String provider, String channel, Number amount, String redemption, User user) {
+	public RedemptionEvent(String type, Instant instant, String provider, String channel, EventAlert alert, RedemptionItem item, Redeemer redeemer, boolean completed, String ID, String redeemerType, Instant updated) {
 		super(type, instant, provider, channel);
-		this.redemption = redemption;
-		this.amount = amount;
-		this.user = user;
+		this.redeemerType = redeemerType;
+		this.completed = completed;
+		this.redeemer = redeemer;
+		this.updated = updated;
+		this.alert = alert;
+		this.item = item;
+		this.ID = ID;
 	}
 
 	/**
-	 * @return The redemption item's name.
+	 * @return The redeemer type of the redemption event.
+	 */
+	public String getRedeemerType() {
+		return redeemerType;
+	}
+	
+	/**
+	 * @return The item and all it's properties involved in the redemption event.
+	 */
+	public RedemptionItem getItem() {
+		return item;
+	}
+
+	/**
+	 * @return The redeemer of the redemption event.
 	 */
-	public String getRedemption() {
-		return redemption;
+	public Redeemer getRedeemer() {
+		return redeemer;
 	}
 
 	/**
-	 * @return The amount the redemption item cost.
+	 * @return Grab the alert setting for this redemption.
+	 */
+	public EventAlert getAlert() {
+		return alert;
+	}
+	
+	/**
+	 * @return If the redemption was completed.
 	 */
-	public Number getAmount() {
-		return amount;
+	public boolean isCompleted() {
+		return completed;
 	}
 
 	/**
-	 * @return The User that initiated the redemption.
+	 * @return The last Instant that this redemption item was updated.
+	 */
+	public Instant getUpdated() {
+		return updated;
+	}
+
+	/**
+	 * @return The ID of the redemption transaction.
 	 */
-	public User getUser() {
-		return user;
+	public String getID() {
+		return ID;
 	}
 
 }

src/main/java/me/limeglass/streamelements/internals/StreamElementsClient.java

@@ -21,6 +21,7 @@ public class StreamElementsClient implements StreamElements {
 
 	private final String token, account;
 	private Class<?>[] listeners;
+	private String[] emitters;
 	private final int timeout;
 	private Socket socket;
 
@@ -30,10 +31,13 @@ public class StreamElementsClient implements StreamElements {
 	 * @param token The JWT token used from StreamElements. (Found under account)
 	 * @param accountID The account ID used from StreamElements. (Found under account)
 	 */
-	public StreamElementsClient(String token, String account, int timeout, Class<?>[] listeners) {
+	public StreamElementsClient(String token, String account, int timeout, Class<?>[] listeners, String... emitters) {
 		ElementsReaderHandler.load("me.limeglass.streamelements.internals.readers");
 		if (listeners != null && listeners.length > 0)
 			this.listeners = EventDispatcher.registerListeners(listeners);
+		SocketListener.registerEmitters(this, "me.limeglass.streamelements.events.emitters.types");
+		if (emitters != null && emitters.length > 0)
+			this.emitters = SocketListener.registerEmitters(this, emitters);
 		this.socket = SocketListener.registerSocket(this);
 		this.account = account;
 		this.timeout = timeout;
@@ -46,6 +50,13 @@ public StreamElementsClient(String token, String account, int timeout, Class<?>[
 	public Class<?>[] getListeners() {
 		return listeners;
 	}
+	
+	/**
+	 * @return The emitters to be registered.
+	 */
+	public String[] getEmitters() {
+		return emitters;
+	}
 
 	/**
 	 * @return the StreamElements Account ID of the client.

src/main/java/me/limeglass/streamelements/internals/dummy/Cancellable.java

@@ -0,0 +1,16 @@
+package me.limeglass.streamelements.internals.dummy;
+
+public interface Cancellable {
+
+	/**
+	 * @return Checks if the event is cancelled or not.
+	 */
+	boolean isCancelled();
+	
+	/**
+	 * Cancels the event.
+	 * @param cancel If the event should be cancelled or not.
+	 */
+	void setCancelled(boolean cancel);
+	
+}

src/main/java/me/limeglass/streamelements/internals/dummy/ElementsResponse.java

@@ -0,0 +1,5 @@
+package me.limeglass.streamelements.internals.dummy;
+
+public class ElementsResponse {
+	
+}

src/main/java/me/limeglass/streamelements/internals/events/EventDispatcher.java

@@ -56,18 +56,19 @@ public static Class<?> registerListener(Class<?> clazz, Object listener) {
 	 * Used internally, call this when an event happens to trigger the API events.
 	 * 
 	 * @param event The ElementsEvent that just happened.
+	 * @return 
 	 */
-	public static void dispatch(ElementsEvent event) {
-		registered.parallelStream()
-				.filter(check -> check.accepts(event))
-				.forEach(handler -> {
-					try {
-						handler.handle(event);
-					} catch (Throwable e) {
-						System.out.println("Error dispatching event " + event.getClass().getSimpleName());
-						e.printStackTrace();
-					}
-				});
+	public static ElementsEvent dispatch(ElementsEvent event) {
+		for (MethodHandler handler : registered) {
+			if (handler.accepts(event))
+				try {
+					return handler.handle(event);
+				} catch (Throwable e) {
+					System.out.println("Error dispatching event " + event.getClass().getSimpleName());
+					e.printStackTrace();
+				}
+		}
+		return event;
 	}
 
 	/**
@@ -86,13 +87,14 @@ public MethodHandler(MethodHandle handle, Class<?> listenerClass, Class<?> event
 			this.handle = handle;
 		}
 
-		public void handle(ElementsEvent event) throws Throwable {
+		public ElementsEvent handle(ElementsEvent event) throws Throwable {
 			Constructor<?>[] constructors = listenerClass.getConstructors();
 			if (constructors.length > 0 && constructors[0].getParameterCount() > 0 && listener == null)
 				throw new IllegalArgumentException("The listener instance may not be null and have a constructor at the same time.\n Use registerListener(Listener.class, new SubClassListener())");
 			if (listener == null)
 				listener = listenerClass.newInstance();
 			handle.invoke(listener, event);
+			return event;
 		};
 
 		public boolean accepts(ElementsEvent event) {

src/main/java/me/limeglass/streamelements/internals/events/SocketListener.java

@@ -4,14 +4,14 @@
 import java.net.URISyntaxException;
 import java.util.HashSet;
 import java.util.Set;
-
 import org.reflections.Reflections;
 
 import com.google.common.collect.Sets;
 
 import io.socket.client.IO;
 import io.socket.client.Socket;
 import me.limeglass.streamelements.api.StreamElements;
+import me.limeglass.streamelements.api.events.EmitterRegisterEvent;
 import me.limeglass.streamelements.internals.events.emitters.ElementsEmitter;
 import me.limeglass.streamelements.internals.events.emitters.EventEmitter;
 
@@ -23,8 +23,9 @@ public class SocketListener {
 
 	public static Socket registerSocket(StreamElements instance) {
 		try {
+			emitters.clear();
 			Reflections reflections = new Reflections("me.limeglass.streamelements.internals.events.emitters");
-			for (Class<? extends ElementsEmitter> emitterClass : reflections.getSubTypesOf(ElementsEmitter.class)) {
+			emitter : for (Class<? extends ElementsEmitter> emitterClass : reflections.getSubTypesOf(ElementsEmitter.class)) {
 				ElementsEmitter emitter;
 				try {
 					emitter = emitterClass.getDeclaredConstructor(StreamElements.class).newInstance(instance);
@@ -33,7 +34,15 @@ public static Socket registerSocket(StreamElements instance) {
 						continue;
 					emitter = emitterClass.newInstance();
 				}
-				emitters.add(emitter);
+				for (ElementsEmitter e : emitters) {
+					if (e.getEventName().equals(emitter.getEventName())) {
+						continue emitter;
+					}
+				}
+				EmitterRegisterEvent event = new EmitterRegisterEvent(emitter);
+				EventDispatcher.dispatch(event);
+				if (!event.isCancelled())
+						emitters.add(emitter);
 			}
 			IO.Options options = new IO.Options();
 			options.forceNew = true;
@@ -55,6 +64,36 @@ public static Socket getSocket() {
 		return socket;
 	}
 
+	public static String[] registerEmitters(StreamElements instance, String... registerEmitters) {
+		try {
+			for (String emitterPackage : registerEmitters) {
+				Reflections reflections = new Reflections(emitterPackage);
+				emitter : for (Class<? extends ElementsEmitter> emitterClass : reflections.getSubTypesOf(ElementsEmitter.class)) {
+					ElementsEmitter emitter;
+					try {
+						emitter = emitterClass.getDeclaredConstructor(StreamElements.class).newInstance(instance);
+					} catch (NoSuchMethodException e) {
+						if (ignored.contains(emitterClass))
+							continue;
+						emitter = emitterClass.newInstance();
+					}
+					for (ElementsEmitter e : emitters) {
+						if (e.getEventName().equals(emitter.getEventName())) {
+							continue emitter;
+						}
+					}
+					EmitterRegisterEvent event = new EmitterRegisterEvent(emitter);
+					EventDispatcher.dispatch(event);
+					if (!event.isCancelled())
+						emitters.add(emitter);
+				}
+			}
+		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException e) {
+			e.printStackTrace();
+		}
+		return registerEmitters;
+	}
+	
 	/**
 	 * Useful for adding emitters that shouldn't be read as a logical ElementsEmitter. Example being EventEmitter.
 	 * @param emitter The class that extends ElementsEmitter.

src/main/java/me/limeglass/streamelements/internals/events/emitters/EventEmitter.java

@@ -35,17 +35,25 @@ public EventEmitter(String type) {
 		}
 	}
 	*/
+	
+	@Override
+	public String getEventName() {
+		return type;
+	}
 
 	@Override
 	public void call(Socket socket, Object... args) {
 		JSONObject object = (JSONObject)args[0];
-		System.out.println("Event: " + object.toString());
-		provider = object.getString("provider");
+		if (object.has("provider"))
+			provider = object.getString("provider");
+		else 
+			provider = "twitch";
 		instant = Instant.parse(object.getString("createdAt"));
 		channel = object.getString("channel");
-		System.out.println("Event: " + object.toString());
-		if (object.getString("type").equalsIgnoreCase(type))
+		if (object.has("type") && object.getString("type").equalsIgnoreCase(type))
 			call(socket, object.getJSONObject("data"));
+		else if (object.has("redeemerType") && type.equalsIgnoreCase("redemption"))
+			call(socket, object);
 	}
 
 	protected abstract void call(Socket socket, JSONObject data);