Use LambdaMetaFactory to generate accessors for @Subscribe annotations

runelite-client/src/main/java/net/runelite/client/eventbus/AccessorGenerator.java

@@ -0,0 +1,85 @@
+package net.runelite.client.eventbus;
+
+import com.google.common.collect.ImmutableSet;
+import io.reactivex.functions.Consumer;
+import java.lang.invoke.CallSite;
+import java.lang.invoke.LambdaMetafactory;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.lang.invoke.MethodType;
+import static java.lang.invoke.MethodType.methodType;
+import java.lang.reflect.Method;
+import java.util.Set;
+import lombok.extern.slf4j.Slf4j;
+import net.runelite.api.events.Event;
+
+@Slf4j
+public class AccessorGenerator
+{
+	public static Set<Subscription> scanSubscribes(Lookup caller, Object ref)
+	{
+		ImmutableSet.Builder<Subscription> builder = ImmutableSet.builder();
+
+		final Class<?> refClass = ref.getClass();
+		caller = getPrivateAccess(refClass, caller).in(refClass);
+
+		for (Method method : refClass.getDeclaredMethods())
+		{
+			Subscribe sub = method.getAnnotation(Subscribe.class);
+			if (sub != null)
+			{
+				final Consumer accessor;
+				final Class paramType = method.getParameterTypes()[0];
+
+				try
+				{
+					accessor = getConsumerFor(caller, ref, method);
+				}
+				catch (Throwable t)
+				{
+					log.warn("Creating consumer lambda for {} failed!", method, t);
+					continue;
+				}
+
+				builder.add(new Subscription(paramType, accessor, sub.takeUntil(), sub.subscribe(), sub.observe()));
+			}
+		}
+		return builder.build();
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <EVENT extends Event> Consumer<EVENT> getConsumerFor(Lookup caller, Object ref, Method method) throws Throwable
+	{
+		final MethodHandle methodHandle = caller.unreflect(method);
+
+		final MethodType actualConsumer  = methodHandle.type().dropParameterTypes(0, 1);
+		final MethodType eventsConsumer = actualConsumer.erase();
+		final MethodType factoryType = methodType(Consumer.class, ref.getClass());
+
+		final CallSite callsite = LambdaMetafactory.metafactory(
+			caller,                 // To get past security checks
+			"accept",  // The name of the method to implement inside the lambda type
+			factoryType,            // Signature of the factory method
+			eventsConsumer,         // Signature of function implementation
+			methodHandle,           // Target method
+			actualConsumer          // Target method signature
+		);
+
+		final MethodHandle factory = callsite.getTarget();
+		return (Consumer<EVENT>) factory.invoke(ref);
+	}
+
+	private static Lookup getPrivateAccess(Class<?> into, Lookup from)
+	{
+		try
+		{
+			return MethodHandles.privateLookupIn(into, from);
+		}
+		catch (IllegalAccessException a)
+		{
+			log.warn("Failed to get private access in {} from {}", into, from, a);
+			return from;
+		}
+	}
+}

runelite-client/src/main/java/net/runelite/client/eventbus/Subscription.java

@@ -0,0 +1,20 @@
+package net.runelite.client.eventbus;
+
+import io.reactivex.functions.Consumer;
+import lombok.Value;
+
+@Value
+public class Subscription
+{
+	private final Class type;
+	private final Consumer method;
+	private final int takeUntil;
+	private final EventScheduler subscribe;
+	private final EventScheduler observe;
+
+	@SuppressWarnings("unchecked")
+	public void subscribe(EventBus eventBus, Object lifecycle)
+	{
+		eventBus.subscribe(type, lifecycle, method, takeUntil, subscribe, observe);
+	}
+}

runelite-client/src/main/java/net/runelite/client/plugins/Plugin.java

@@ -24,25 +24,23 @@
  */
 package net.runelite.client.plugins;
 
-import com.google.common.collect.ImmutableSet;
 import com.google.inject.Binder;
 import com.google.inject.Injector;
 import com.google.inject.Module;
-import io.reactivex.functions.Consumer;
-import java.lang.reflect.Method;
+import io.reactivex.Observable;
+import io.reactivex.schedulers.Schedulers;
+import java.lang.invoke.MethodHandles;
+import java.util.Collection;
 import java.util.Set;
 import lombok.AccessLevel;
 import lombok.Getter;
-import lombok.Value;
-import net.runelite.api.events.Event;
+import net.runelite.client.eventbus.AccessorGenerator;
 import net.runelite.client.eventbus.EventBus;
-import net.runelite.client.eventbus.EventScheduler;
-import net.runelite.client.eventbus.Subscribe;
+import net.runelite.client.eventbus.Subscription;
 
 public abstract class Plugin implements Module
 {
-	private final Set<Subscription> annotatedSubscriptions = findSubscriptions();
-	private final Object annotatedSubsLock = new Object();
+	private Set<Subscription> annotatedSubscriptions = null;
 
 	@Getter(AccessLevel.PROTECTED)
 	protected Injector injector;
@@ -60,53 +58,33 @@ public abstract class Plugin implements Module
 	{
 	}
 
-	@SuppressWarnings("unchecked")
 	final void addAnnotatedSubscriptions(EventBus eventBus)
 	{
-		annotatedSubscriptions.forEach(sub -> eventBus.subscribe(sub.type, annotatedSubsLock, sub.method, sub.takeUntil, sub.subscribe, sub.observe));
+		if (annotatedSubscriptions == null)
+		{
+			Observable.fromCallable(this::findSubscriptions)
+				.subscribeOn(Schedulers.computation())
+				.observeOn(Schedulers.single())
+				.subscribe(subs -> addSubs(eventBus, (annotatedSubscriptions = subs)));
+		}
+		else
+		{
+			addSubs(eventBus, annotatedSubscriptions);
+		}
 	}
 
 	final void removeAnnotatedSubscriptions(EventBus eventBus)
 	{
-		eventBus.unregister(annotatedSubsLock);
+		eventBus.unregister(this);
 	}
 
 	private Set<Subscription> findSubscriptions()
 	{
-		ImmutableSet.Builder<Subscription> builder = ImmutableSet.builder();
-
-		for (Method method : this.getClass().getDeclaredMethods())
-		{
-			Subscribe annotation = method.getAnnotation(Subscribe.class);
-			if (annotation == null)
-			{
-				continue;
-			}
-
-			assert method.getParameterCount() == 1 : "Methods annotated with @Subscribe should have only one parameter";
-
-			Class<?> type = method.getParameterTypes()[0];
-
-			assert Event.class.isAssignableFrom(type) : "Parameters of methods annotated with @Subscribe should implement net.runelite.api.events.Event";
-			assert method.getReturnType() == void.class : "Methods annotated with @Subscribe should have a void return type";
-
-			method.setAccessible(true);
-
-			Subscription sub = new Subscription(type.asSubclass(Event.class), event -> method.invoke(this, event), annotation.takeUntil(), annotation.subscribe(), annotation.observe());
-
-			builder.add(sub);
-		}
-
-		return builder.build();
+		return AccessorGenerator.scanSubscribes(MethodHandles.lookup(), this);
 	}
 
-	@Value
-	private static class Subscription
+	private void addSubs(EventBus eventBus, Collection<Subscription> subs)
 	{
-		private final Class type;
-		private final Consumer method;
-		private final int takeUntil;
-		private final EventScheduler subscribe;
-		private final EventScheduler observe;
+		subs.forEach(s -> s.subscribe(eventBus, this));
 	}
 }

runelite-client/src/main/java/net/runelite/client/plugins/PluginManager.java

@@ -25,6 +25,7 @@
 package net.runelite.client.plugins;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.graph.Graph;
@@ -218,13 +219,17 @@ public class PluginManager
 	public void startCorePlugins()
 	{
 		List<Plugin> scannedPlugins = new ArrayList<>(plugins);
-		int loaded = 0;
+		int loaded = 0, started = 0;
 
+		final Stopwatch timer = Stopwatch.createStarted();
 		for (Plugin plugin : scannedPlugins)
 		{
 			try
 			{
-				startPlugin(plugin);
+				if (startPlugin(plugin))
+				{
+					++started;
+				}
 			}
 			catch (PluginInstantiationException ex)
 			{
@@ -236,6 +241,8 @@ public class PluginManager
 
 			RuneLiteSplashScreen.stage(.80, 1, "Starting plugins", loaded, scannedPlugins.size());
 		}
+
+		log.debug("Started {}/{} plugins in {}", started, loaded, timer);
 	}
 
 	@SuppressWarnings("unchecked")