Examples with RegisteredListener org.bukkit.plugin.RegisteredListener used on opensource projects

Example 1 with RegisteredListener

use of org.bukkit.plugin.RegisteredListener in project Bukkit by Bukkit.

the class JavaPluginLoader method createRegisteredListeners.

public Map<Class<? extends Event>, Set<RegisteredListener>> createRegisteredListeners(Listener listener, final Plugin plugin) {
    Validate.notNull(plugin, "Plugin can not be null");
    Validate.notNull(listener, "Listener can not be null");
    boolean useTimings = server.getPluginManager().useTimings();
    Map<Class<? extends Event>, Set<RegisteredListener>> ret = new HashMap<Class<? extends Event>, Set<RegisteredListener>>();
    Set<Method> methods;
    try {
        Method[] publicMethods = listener.getClass().getMethods();
        methods = new HashSet<Method>(publicMethods.length, Float.MAX_VALUE);
        for (Method method : publicMethods) {
            methods.add(method);
        }
        for (Method method : listener.getClass().getDeclaredMethods()) {
            methods.add(method);
        }
    } catch (NoClassDefFoundError e) {
        plugin.getLogger().severe("Plugin " + plugin.getDescription().getFullName() + " has failed to register events for " + listener.getClass() + " because " + e.getMessage() + " does not exist.");
        return ret;
    }
    for (final Method method : methods) {
        final EventHandler eh = method.getAnnotation(EventHandler.class);
        if (eh == null)
            continue;
        final Class<?> checkClass;
        if (method.getParameterTypes().length != 1 || !Event.class.isAssignableFrom(checkClass = method.getParameterTypes()[0])) {
            plugin.getLogger().severe(plugin.getDescription().getFullName() + " attempted to register an invalid EventHandler method signature \"" + method.toGenericString() + "\" in " + listener.getClass());
            continue;
        }
        final Class<? extends Event> eventClass = checkClass.asSubclass(Event.class);
        method.setAccessible(true);
        Set<RegisteredListener> eventSet = ret.get(eventClass);
        if (eventSet == null) {
            eventSet = new HashSet<RegisteredListener>();
            ret.put(eventClass, eventSet);
        }
        for (Class<?> clazz = eventClass; Event.class.isAssignableFrom(clazz); clazz = clazz.getSuperclass()) {
            // This loop checks for extending deprecated events
            if (clazz.getAnnotation(Deprecated.class) != null) {
                Warning warning = clazz.getAnnotation(Warning.class);
                WarningState warningState = server.getWarningState();
                if (!warningState.printFor(warning)) {
                    break;
                }
                plugin.getLogger().log(Level.WARNING, String.format("\"%s\" has registered a listener for %s on method \"%s\", but the event is Deprecated." + " \"%s\"; please notify the authors %s.", plugin.getDescription().getFullName(), clazz.getName(), method.toGenericString(), (warning != null && warning.reason().length() != 0) ? warning.reason() : "Server performance will be affected", Arrays.toString(plugin.getDescription().getAuthors().toArray())), warningState == WarningState.ON ? new AuthorNagException(null) : null);
                break;
            }
        }
        EventExecutor executor = new EventExecutor() {

            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);
                }
            }
        };
        if (useTimings) {
            eventSet.add(new TimedRegisteredListener(listener, executor, eh.priority(), plugin, eh.ignoreCancelled()));
        } else {
            eventSet.add(new RegisteredListener(listener, executor, eh.priority(), plugin, eh.ignoreCancelled()));
        }
    }
    return ret;
}

Example 2 with RegisteredListener

use of org.bukkit.plugin.RegisteredListener in project Dragonet-Legacy by DragonetMC.

the class MixedPluginManager method registerEvent.

/**
     * Registers the given event to the specified listener using a directly
     * passed EventExecutor
     *
     * @param event Event class to register
     * @param listener PlayerListener to register
     * @param priority Priority of this event
     * @param executor EventExecutor to register
     * @param plugin Plugin to register
     * @param ignoreCancelled Do not call executor if event was already
     *     cancelled
     */
@Override
public void registerEvent(Class<? extends Event> event, Listener listener, EventPriority priority, EventExecutor executor, Plugin plugin, boolean ignoreCancelled) {
    Validate.notNull(listener, "Listener cannot be null");
    Validate.notNull(priority, "Priority cannot be null");
    Validate.notNull(executor, "Executor cannot be null");
    Validate.notNull(plugin, "Plugin cannot be null");
    if (!plugin.isEnabled()) {
        throw new IllegalPluginAccessException("Plugin attempted to register " + event + " while not enabled");
    }
    if (useTimings) {
        getEventListeners(event).register(new TimedRegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
    } else {
        getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
    }
}

Example 3 with RegisteredListener

use of org.bukkit.plugin.RegisteredListener in project Dragonet-Legacy by DragonetMC.

the class MixedPluginManager method fireEvent.

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

Example 4 with RegisteredListener

use of org.bukkit.plugin.RegisteredListener in project TotalFreedomMod by TotalFreedom.

the class FrontDoor method getRegisteredListener.

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;
}

Example 5 with RegisteredListener

use of org.bukkit.plugin.RegisteredListener in project BKCommonLib by bergerhealer.

the class CommonUtil method setListenerOrder.

private static void setListenerOrder(Listener listener, Class<?> eventClass, boolean first) {
    HandlerList list = getEventHandlerList(eventClass);
    final EventPriority prio = first ? EventPriority.LOWEST : EventPriority.MONITOR;
    synchronized (list) {
        EnumMap<EventPriority, ArrayList<RegisteredListener>> handlerSlots = BHandlerList.handlerslots.get(list);
        ArrayList<RegisteredListener> registeredListenerList = handlerSlots.get(prio);
        int requestedIndex = first ? 0 : (registeredListenerList.size() - 1);
        // Try to find the registered listener
        for (int i = 0; i < registeredListenerList.size(); i++) {
            RegisteredListener registeredListener = registeredListenerList.get(i);
            // Check that the Listener matches
            if (registeredListener.getListener() != listener) {
                continue;
            } else if (i == requestedIndex) {
                // Already in order, do not do anything
                return;
            }
            RegisteredListener[] allListeners = list.getRegisteredListeners();
            // Change order in list
            registeredListenerList.remove(i);
            registeredListenerList.add(requestedIndex, registeredListener);
            // Get the index of the listener in the baked array
            ArrayList<RegisteredListener> newListeners = new ArrayList<RegisteredListener>(allListeners.length);
            if (first) {
                newListeners.add(registeredListener);
                for (RegisteredListener otherListener : allListeners) {
                    if (otherListener != registeredListener) {
                        newListeners.add(otherListener);
                    }
                }
            } else {
                for (RegisteredListener otherListener : allListeners) {
                    if (otherListener != registeredListener) {
                        newListeners.add(otherListener);
                    }
                }
                newListeners.add(registeredListener);
            }
            // Transfer the listeners over
            if (newListeners.toArray(allListeners) != allListeners) {
                // Strange failure, ensure a bake
                list.bake();
            }
            return;
        }
    }
}