if (event.getHandlers().getRegisteredListeners().length == 0) { return event;
if ("reset".equals(args[0])) { for (HandlerList handlerList : HandlerList.getHandlerLists()) { for (RegisteredListener listener : handlerList.getRegisteredListeners()) { if (listener instanceof TimedRegisteredListener) { ((TimedRegisteredListener)listener).reset(); for (RegisteredListener listener : HandlerList.getRegisteredListeners(plugin)) { if (listener instanceof TimedRegisteredListener) { TimedRegisteredListener trl = (TimedRegisteredListener) listener;
private void fireEvent(Event event) { HandlerList handlers = event.getHandlers(); RegisteredListener[] listeners = handlers.getRegisteredListeners(); for (RegisteredListener registration : listeners) { if (!registration.getPlugin().isEnabled()) { continue; } try { registration.callEvent(event); } catch (AuthorNagException ex) { Plugin plugin = registration.getPlugin(); if (plugin.isNaggable()) { plugin.setNaggable(false); server.getLogger().log(Level.SEVERE, String.format( "Nag author(s): '%s' of '%s' about the following: %s", plugin.getDescription().getAuthors(), plugin.getDescription().getFullName(), ex.getMessage() )); } } catch (Throwable ex) { server.getLogger().log(Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex); } } }
/** * Handles pre-hooks for a player login. * * @param name the name of the player who is logging in * @param address the address of the player who is logging in * @param uuid the UUID of the player who is logging in, provided by Mojang * @return an AsyncPlayerPreLoginEvent */ @SuppressWarnings("deprecation") public AsyncPlayerPreLoginEvent onPlayerPreLogin(String name, InetSocketAddress address, UUID uuid) { // call async event AsyncPlayerPreLoginEvent event = new AsyncPlayerPreLoginEvent(name, address .getAddress(), uuid); callEvent(event); // call sync event only if needed if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length > 0) { // initialize event to match current state from async event PlayerPreLoginEvent syncEvent = new PlayerPreLoginEvent(name, address .getAddress(), uuid); if (event.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) { syncEvent.disallow(event.getResult(), event.getKickMessage()); } // call event synchronously and copy data back to original event callEvent(syncEvent); event.disallow(syncEvent.getResult(), syncEvent.getKickMessage()); } return event; }
&& VehicleMoveEvent.getHandlerList().getRegisteredListeners().length > 0) { EventFactory.getInstance().callEvent( new VehicleMoveEvent((Vehicle) vehicle, oldLocation, newLocation.clone()));
/** * Handles an incoming chat message. * * @param async This changes the event to a synchronous state. * @param player the sending player * @param message the message * @return the completed event */ @SuppressWarnings("deprecation") public AsyncPlayerChatEvent onPlayerChat(boolean async, Player player, String message) { // call async event Set<Player> recipients = new HashSet<>(player.getServer().getOnlinePlayers()); AsyncPlayerChatEvent event = new AsyncPlayerChatEvent(async, player, message, recipients); callEvent(event); // call sync event only if needed if (PlayerChatEvent.getHandlerList().getRegisteredListeners().length > 0) { // initialize event to match current state from async event PlayerChatEvent syncEvent = new PlayerChatEvent(player, event.getMessage(), event .getFormat(), recipients); syncEvent.setCancelled(event.isCancelled()); // call event synchronously and copy data back to original event callEvent(syncEvent); event.setMessage(syncEvent.getMessage()); event.setFormat(syncEvent.getFormat()); event.setCancelled(syncEvent.isCancelled()); } return event; }
&& PlayerMoveEvent.getHandlerList().getRegisteredListeners().length > 0) { PlayerMoveEvent event = EventFactory.getInstance() .callEvent(new PlayerMoveEvent(player, oldLocation, newLocation));
/** * Checks whether the event handler list of an event has registered listeners<br> * If creating an event causes a performance drain, useless event creation can be avoided this way * * @param handlerList of the Event * @return True if handlers are contained, False if not */ public static boolean hasHandlers(HandlerList handlerList) { return handlerList.getRegisteredListeners().length > 0; }
private void checkBuildListeners() { buildListeners.clear(); HandlerList handlers = BlockPlaceEvent.getHandlerList(); for (RegisteredListener listener : handlers.getRegisteredListeners()) { if (plugins.contains(listener.getPlugin())) { buildListeners.add(listener); } } }
private void checkBreakListeners() { breakListeners.clear(); HandlerList handlers = BlockBreakEvent.getHandlerList(); for (RegisteredListener listener : handlers.getRegisteredListeners()) { if (plugins.contains(listener.getPlugin())) { breakListeners.add(listener); } } }
/** * Build a cache of listeners registered for an event. * * @param event The event * @return A list of handlers */ private static List<Handler> getHandlers(Event event) { List<Handler> handlers = Lists.newArrayList(); for (RegisteredListener listener : event.getHandlers().getRegisteredListeners()) { handlers.add(new Handler(listener.getListener().getClass().getName(), listener.getPlugin())); } return handlers; }
private static RegisteredListener getRegisteredListener(Listener listener, Class<? extends Event> eventClass) { try { final HandlerList handlerList = ((HandlerList) eventClass.getMethod("getHandlerList", (Class<?>[]) null).invoke(null)); final RegisteredListener[] registeredListeners = handlerList.getRegisteredListeners(); for (RegisteredListener registeredListener : registeredListeners) { if (registeredListener.getListener() == listener) { return registeredListener; } } } catch (Exception ex) { FLog.severe(ex); } return null; }
public static void inject(Plugin plg) { if (plg != null) { for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) { try { FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class); EventExecutor fieldEventExecutor = field.get(listener); field.set(listener, new EventExecutorInjector(plg, fieldEventExecutor)); } catch (Exception e) { e.printStackTrace(); } } } }
public static void uninject(Plugin plg) { if (plg != null) { for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) { try { FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class); EventExecutor executor = field.get(listener); if (executor instanceof EventExecutorInjector) { field.set(listener, ((EventExecutorInjector) executor).getEventExecutor()); } } catch (Exception e) { e.printStackTrace(); } } } }
public static Map<String, MonitorRecord> getEventTimingsByPlugin(Plugin plg) { Map<String, MonitorRecord> record = new HashMap<>(); if (plg == null) { return record; } for (RegisteredListener listener : HandlerList.getRegisteredListeners(plg)) { try { FieldAccessor<EventExecutor> field = Reflection.getField(RegisteredListener.class, "executor", EventExecutor.class); EventExecutor executor = field.get(listener); if (executor instanceof EventExecutorInjector) { EventExecutorInjector eventExecutorInjector = (EventExecutorInjector) executor; String eventName = eventExecutorInjector.getEventName(); if (eventName != null) { MonitorRecord monitorRecord = getMonitorRecord(eventName, eventExecutorInjector.getTotalTime(), eventExecutorInjector.getTotalCount(), eventExecutorInjector.getMaxExecuteTime()); if (record.containsKey(eventName)) { MonitorRecord otherMonitorRecord = record.get(eventName); record.put(eventName, otherMonitorRecord.merge(monitorRecord)); } else { record.put(eventName, monitorRecord); } } } } catch (Exception e) { e.printStackTrace(); } } return record; }
private void fireEvent(Event event) { HandlerList handlers = event.getHandlers(); RegisteredListener[] listeners = handlers.getRegisteredListeners(); for (RegisteredListener registration : listeners) { if (!registration.getPlugin().isEnabled()) { continue; } try { registration.callEvent(event); } catch (AuthorNagException ex) { Plugin plugin = registration.getPlugin(); if (plugin.isNaggable()) { plugin.setNaggable(false); server.getLogger().log(Level.SEVERE, String.format( "Nag author(s): '%s' of '%s' about the following: %s", plugin.getDescription().getAuthors(), plugin.getDescription().getFullName(), ex.getMessage() )); } } catch (Throwable ex) { server.getLogger().log(Level.SEVERE, "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName(), ex); } } }
/** * Launches an update check task. If updateChecker already registered (i.e. reload), does not check for update * again. If CheckForUpdate switched to false unregisters listener. */ private void launchUpdateChecker() { if (!mainConfig.getBoolean("CheckForUpdate", true)) { PlayerJoinEvent.getHandlerList().unregister(updateChecker.get()); } else { for (RegisteredListener registeredListener : PlayerJoinEvent.getHandlerList().getRegisteredListeners()) { if (registeredListener.getListener() == updateChecker) { return; } } advancedAchievements.getServer().getPluginManager().registerEvents(updateChecker.get(), advancedAchievements); updateChecker.get().launchUpdateCheckerTask(); } }
@Override public SpoofedData apply(String hostname) { if (PlayerHandshakeEvent.getHandlerList().getRegisteredListeners().length != 0) { PlayerHandshakeEvent handshakeEvent = new PlayerHandshakeEvent(hostname, false); Bukkit.getPluginManager().callEvent(handshakeEvent); if (!handshakeEvent.isCancelled()) { if (handshakeEvent.isFailed()) { return new SpoofedData(handshakeEvent.getFailMessage()); } return new SpoofedData( handshakeEvent.getServerHostname(), handshakeEvent.getSocketAddressHostname(), handshakeEvent.getUniqueId(), Utils.GSON.fromJson(handshakeEvent.getPropertiesJson(), properties_type) ); } } return null; }
HandlerList hl = event.getHandlers(); for(RegisteredListener rl : hl.getRegisteredListeners()) debug("Plugin Listening: " + rl.getPlugin().getName(), rodder);
syncEvent.disallow(asyncEvent.getResult(), asyncEvent.getKickMessage()); if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length != 0) { if (ServerPlatform.get().getMiscUtils().callSyncTask(() -> { Bukkit.getPluginManager().callEvent(syncEvent);