/** * Unregister a specific plugin's listeners from all handler lists. * * @param plugin plugin to unregister */ public static void unregisterAll(Plugin plugin) { synchronized (allLists) { for (HandlerList h : allLists) { h.unregister(plugin); } } }
/** * Get the baked registered listeners associated with this handler list * * @return the array of registered listeners */ public RegisteredListener[] getRegisteredListeners() { RegisteredListener[] handlers; while ((handlers = this.handlers) == null) bake(); // This prevents fringe cases of returning null return handlers; }
/** * Register a collection of new listeners in this handler list * * @param listeners listeners to register */ public void registerAll(Collection<RegisteredListener> listeners) { for (RegisteredListener listener : listeners) { register(listener); } }
@EventHandler(ignoreCancelled = true) public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) { if (commandRegistration.dispatch(event.getPlayer(), event.getMessage().substring(1))) { event.setCancelled(true); } }
@EventHandler public void onPluginDisable(PluginDisableEvent event) { String name = event.getPlugin().getDescription().getName(); if (event.getPlugin() instanceof PermissionsProvider || "permissions".equalsIgnoreCase(name) || "permissionsex".equalsIgnoreCase(name) || "bpermissions".equalsIgnoreCase(name) || "groupmanager".equalsIgnoreCase(name) || "vault".equalsIgnoreCase(name)) { load(); } }
@EventHandler public void onPluginEnable(PluginEnableEvent event) { Plugin plugin = event.getPlugin(); String name = plugin.getDescription().getName(); if (plugin instanceof PermissionsProvider) { setPluginPermissionsResolver(plugin); } else if ("permissions".equalsIgnoreCase(name) || "permissionsex".equalsIgnoreCase(name) || "bpermissions".equalsIgnoreCase(name) || "groupmanager".equalsIgnoreCase(name) || "vault".equalsIgnoreCase(name)) { load(); } }
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onGamemode(PlayerGameModeChangeEvent event) { if (!plugin.getInternalPlatform().isHookingEvents()) { return; } // this will automatically refresh their session, we don't have to do anything WorldEdit.getInstance().getSessionManager().get(plugin.wrapPlayer(event.getPlayer())); }
/** * 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; }
public void clearPlugins() { synchronized (this) { disablePlugins(); plugins.clear(); lookupNames.clear(); HandlerList.unregisterAll(); fileAssociations.clear(); permissions.clear(); defaultPerms.get(true).clear(); defaultPerms.get(false).clear(); } }
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); } } }
/** * Calls an event with the given details. * <p> * This method only synchronizes when the event is not asynchronous. * * @param event Event details */ public void callEvent(Event event) { if (event.isAsynchronous()) { if (Thread.holdsLock(this)) { throw new IllegalStateException(event.getEventName() + " cannot be triggered asynchronously from inside synchronized code."); } if (server.isPrimaryThread()) { throw new IllegalStateException(event.getEventName() + " cannot be triggered asynchronously from primary server thread."); } fireEvent(event); } else { synchronized (this) { fireEvent(event); } } }
/** * Calls the event executor * * @param event The event * @throws EventException If an event handler throws an exception. */ public void callEvent(final Event event) throws EventException { if (event instanceof Cancellable){ if (((Cancellable) event).isCancelled() && isIgnoringCancelled()){ return; } } executor.execute(listener, event); }
@Override public void callEvent(Event event) throws EventException { if (event.isAsynchronous()) { super.callEvent(event); return; } count++; Class<? extends Event> newEventClass = event.getClass(); if (this.eventClass == null) { this.eventClass = newEventClass; } else if (!this.eventClass.equals(newEventClass)) { multiple = true; this.eventClass = getCommonSuperclass(newEventClass, this.eventClass).asSubclass(Event.class); } long start = System.nanoTime(); super.callEvent(event); totalTime += System.nanoTime() - start; }
public void execute(Listener listener, Event event) throws EventException { try { if (!eventClass.isAssignableFrom(event.getClass())) { return; } method.invoke(listener, event); } catch (InvocationTargetException ex) { throw new EventException(ex.getCause()); } catch (Throwable t) { throw new EventException(t); } } };
public void enablePlugin(final Plugin plugin) { if (!plugin.isEnabled()) { List<Command> pluginCommands = PluginCommandYamlParser.parse(plugin); if (!pluginCommands.isEmpty()) { commandMap.registerAll(plugin.getDescription().getName(), pluginCommands); } try { plugin.getPluginLoader().enablePlugin(plugin); } catch (Throwable ex) { server.getLogger().log(Level.SEVERE, "Error occurred (in the plugin loader) while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex); } HandlerList.bakeAll(); } }
/** * Create a new handler list and initialize using EventPriority. * <p> * The HandlerList is then added to meta-list for use in bakeAll() */ public HandlerList() { handlerslots = new EnumMap<EventPriority, ArrayList<RegisteredListener>>(EventPriority.class); for (EventPriority o : EventPriority.values()) { handlerslots.put(o, new ArrayList<RegisteredListener>()); } synchronized (allLists) { allLists.add(this); } }
/** * Register a new listener in this handler list * * @param listener listener to register */ public synchronized void register(RegisteredListener listener) { if (handlerslots.get(listener.getPriority()).contains(listener)) throw new IllegalStateException("This listener is already registered to priority " + listener.getPriority().toString()); handlers = null; handlerslots.get(listener.getPriority()).add(listener); }
public void registerEvents(Listener listener, Plugin plugin) { if (!plugin.isEnabled()) { throw new IllegalPluginAccessException("Plugin attempted to register " + listener + " while not enabled"); } for (Map.Entry<Class<? extends Event>, Set<RegisteredListener>> entry : plugin.getPluginLoader().createRegisteredListeners(listener, plugin).entrySet()) { getEventListeners(getRegistrationClass(entry.getKey())).registerAll(entry.getValue()); } }
/** * Unregister a specific listener from all handler lists. * * @param listener listener to unregister */ public static void unregisterAll(Listener listener) { synchronized (allLists) { for (HandlerList h : allLists) { h.unregister(listener); } } }
/** * Bake all handler lists. Best used just after all normal event * registration is complete, ie just after all plugins are loaded if * you're using fevents in a plugin system. */ public static void bakeAll() { synchronized (allLists) { for (HandlerList h : allLists) { h.bake(); } } }