org.bukkit.event.server.PluginDisableEvent Java Examples

@EventHandler(priority = EventPriority.HIGHEST)
public void onPluginDisable(PluginDisableEvent event) {
    final String pluginName = event.getPlugin().getName();

    // Call the onPluginDisable method in the permissions manager
    permissionsManager.onPluginDisable(pluginName);

    if ("Essentials".equalsIgnoreCase(pluginName)) {
        pluginHookService.unhookEssentials();
        logger.info("Essentials has been disabled: unhooking");
    } else if ("CMI".equalsIgnoreCase(pluginName)) {
        pluginHookService.unhookCmi();
        spawnLoader.unloadCmiSpawn();
        logger.info("CMI has been disabled: unhooking");
    } else if ("Multiverse-Core".equalsIgnoreCase(pluginName)) {
        pluginHookService.unhookMultiverse();
        logger.info("Multiverse-Core has been disabled: unhooking");
    } else if ("EssentialsSpawn".equalsIgnoreCase(pluginName)) {
        spawnLoader.unloadEssentialsSpawn();
        logger.info("EssentialsSpawn has been disabled: unhooking");
    } else if ("ProtocolLib".equalsIgnoreCase(pluginName)) {
        protocolLibService.disable();
        logger.warning("ProtocolLib has been disabled, unhooking packet adapters!");
    }
}
 

/**
   * Handles the disabling of the plugin
   *
   * @param event the event fired
   * @since 0.5.19
   */
  @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
  public void onPluginDisable(@NotNull PluginDisableEvent event) {
      Plugin thisPlugin = JavaPlugin.getProvidingPlugin(getClass());
      if (event.getPlugin() != thisPlugin) {
          return;
      }

      int counter = 0; //callbacks might open GUIs, eg. in nested menus
int maxCount = 10;
      while (!activeGuiInstances.isEmpty() && counter++ < maxCount) {
          for (Gui gui : new ArrayList<>(activeGuiInstances)) {
              for (HumanEntity viewer : gui.getViewers()) {
                  viewer.closeInventory();
              }
          }
      }

      if (counter == maxCount) {
	thisPlugin.getLogger().warning("Unable to close GUIs on plugin disable: they keep getting opened "
			+ "(tried: " + maxCount + " times)");
}
  }
 

/**
 * this method handles every plugin disable event.
 *
 * @param event event to handle
 */
public void processPluginDisable(final PluginDisableEvent event) {
    if (!PLUGINQUEUE.peek().equals(event.getPlugin())) {
        synchronized (this) {
            PLUGINQUEUE.remove(event.getPlugin());
            return;
        }
    }

    synchronized (this) {
        PLUGINQUEUE.poll();
    }

    final Plugin nextPlugin = PLUGINQUEUE.peek();
    if (nextPlugin != null && nextPlugin.isEnabled()) {
        registerListeners(nextPlugin);
    }
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent event) {
    if ("dynmap".equalsIgnoreCase(event.getPlugin().getName())) {
        DynmapHook.dynmapCommonAPI = null;
    }
    if ("MMOItems".equals(event.getPlugin().getName()) &&
            !Bukkit.getPluginManager().isPluginEnabled("MMOItems")) {
        Civs.mmoItems = null;
        return;
    }
    if ("DiscordSRV".equals(event.getPlugin().getName()) &&
            !Bukkit.getPluginManager().isPluginEnabled("DiscordSRV")) {
        Civs.discordSRV = null;
        return;
    }
    if (Constants.PLACEHOLDER_API.equals(event.getPlugin().getName())) {
        Civs.placeholderAPI = null;
        return;
    }
}
 

@Override
public void disable()
{
    Plugin plugin = Bukkit.getPluginManager().getPlugin("Vault");
    if (plugin != null)
    {
        uninject(plugin);
    }

    PluginEnableEvent.getHandlerList().unregister(this);
    PluginDisableEvent.getHandlerList().unregister(this);
}
 

@EventHandler
void onPluginDisable(PluginDisableEvent event) {
    RedProtect.get().logger.debug(LogLevel.DEFAULT, "Is PluginDisableEvent event.");
    for (Player play : event.getPlugin().getServer().getOnlinePlayers()) {
        play.closeInventory();
    }
}
 

@EventHandler
void onPluginDisable(PluginDisableEvent event) {
    RedProtect.get().logger.debug(LogLevel.DEFAULT, "Is PluginDisableEvent event.");
    for (Player play : event.getPlugin().getServer().getOnlinePlayers()) {
        play.closeInventory();
    }
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent event) {
    PluginHook hook = hookMap.remove(event.getPlugin().getName());
    if (hook instanceof Listener) {
        hook.unregisterEvents();
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPluginDisable(PluginDisableEvent event) {
    if (event.getPlugin().equals(plugin)) {
        closeOpenMenus();
        plugin = null;
    }
}
 

@Override
   public void disable()
   {
       Plugin plugin = Bukkit.getPluginManager().getPlugin("PlaceholderAPI");
       if (plugin != null)
       {
//           provider.unregister();
       }

       PluginEnableEvent.getHandlerList().unregister(this);
       PluginDisableEvent.getHandlerList().unregister(this);
   }
 

@EventHandler
  public void onPluginDisable(PluginDisableEvent e)
  {
      if (!e.getPlugin().getName().equalsIgnoreCase("PlaceholderAPI"))
      {
          return;
      }
//           provider.unregister();       
  }
 

@Override
public void disable()
{
    Plugin plugin = Bukkit.getPluginManager().getPlugin("Essentials");
    if (plugin != null)
    {
        uninject(plugin);
    }

    PluginEnableEvent.getHandlerList().unregister(this);
    PluginDisableEvent.getHandlerList().unregister(this);
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent e)
{
    if (!e.getPlugin().getName().equalsIgnoreCase("Essentials"))
    {
        return;
    }
    uninject(e.getPlugin());
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPluginDisable(PluginDisableEvent event)
{
    if (perms != null)
    {
        if (event.getPlugin().getDescription().getName().equals("BungeePerms"))
        {
            perms = null;
            log.info(String.format("[%s][Permission] %s un-hooked.", plugin.getDescription().getName(), name));
        }
    }
}
 

@EventHandler
void onPluginDisable(PluginDisableEvent event) {
    RedProtect.get().logger.debug(LogLevel.DEFAULT, "Is PluginDisableEvent event.");
    for (Player play : event.getPlugin().getServer().getOnlinePlayers()) {
        play.closeInventory();
    }
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent e)
{
    if (!e.getPlugin().getName().equalsIgnoreCase("vault"))
    {
        return;
    }
    uninject(e.getPlugin());
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPluginDisable(PluginDisableEvent event)
{

    if (perms != null)
    {
        Plugin permPlugin = event.getPlugin();
        if (permPlugin.getDescription().getName().equals("BungeePerms"))
        {
            perms = null;
            log.info(String.format("[%s][Chat] %s unhooked.", plugin.getDescription().getName(), name));
        }
    }
}
 

@Override
public void disable()
{
    Plugin plugin = Bukkit.getPluginManager().getPlugin("WorldEdit");
    if (plugin != null)
    {
        uninject(plugin);
    }

    PluginEnableEvent.getHandlerList().unregister(this);
    PluginDisableEvent.getHandlerList().unregister(this);
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent e)
{
    if (!e.getPlugin().getName().equalsIgnoreCase("worldedit"))
    {
        return;
    }
    uninject(e.getPlugin());
}
 

/**
 * Check for disabled plugin to remove the associated replacer
 *
 * @param disableEvent the disable event
 */
@EventHandler
public void onPluginDisable(PluginDisableEvent disableEvent) {
    //Remove the listener if the associated plugin was disabled
    Plugin disablePlugin = disableEvent.getPlugin();

    replaceManager.unregisterAll(disablePlugin);
}
 

private void checkDisableHandling(String pluginName, Runnable verifier) {
    PluginDisableEvent event = mockEventWithPluginName(PluginDisableEvent.class, pluginName);
    serverListener.onPluginDisable(event);
    verifier.run();
    verify(permissionsManager).onPluginDisable(pluginName);
    verifyNoMoreInteractionsAndReset();
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
void onPluginDisable(PluginDisableEvent event) {
	String pluginName = event.getPlugin().getName();
	if (pluginName.equals(CitizensHandler.PLUGIN_NAME)) {
		CitizensHandler.disable();
	}
}
 

@EventHandler
protected void onPluginDisable(PluginDisableEvent event) {
    if (hasEntityManager(event.getPlugin())) {
        EntityManager entityManager = getManagerFor(event.getPlugin());
        entityManager.despawnAll(DespawnReason.PLUGIN_DISABLE);
    }
}
 

@Override
public void registerShutdownHandler(TaskChainFactory factory) {
    Bukkit.getPluginManager().registerEvents(new Listener() {
        @EventHandler
        public void onPluginDisable(PluginDisableEvent event) {
            if (event.getPlugin().equals(plugin)) {
                factory.shutdown(60, TimeUnit.SECONDS);
            }
        }
    }, plugin);
}
 

public boolean togglePlugin(Plugin plugin, boolean on) {
  if (plugin.isEnabled() == on) return true;

  try {
    final Field enabled = JavaPlugin.class.getDeclaredField("isEnabled");
    enabled.setAccessible(true);

    if (on) {
      enabled.setBoolean(plugin, true);
      plugin.onEnable();
    } else {
      plugin.onDisable();
      enabled.setBoolean(plugin, false);
    }

    final PluginEvent event = on ? new PluginEnableEvent(plugin) : new PluginDisableEvent(plugin);
    server.getPluginManager().callEvent(event);

    return true;
  } catch (NoSuchFieldException | IllegalAccessException e) {
    server.getLogger().log(Level.SEVERE, "Could not toggle plugin state", e);
  } catch (Throwable t) {
    server
        .getLogger()
        .log(
            Level.WARNING,
            "Could not " + (on ? "load" : "unload") + " plugin " + plugin.getName(),
            t);
  }

  return false;
}
 

@EventHandler(priority = EventPriority.HIGH)
public void onPluginUnload(PluginDisableEvent e) {
  String n = e.getPlugin().getName();

  if (n == null) {
    return;
  }

  if (n.equals(plugin.getName())) {
    return;
  }

  Map<String, PlaceholderHook> hooks = PlaceholderAPI.getPlaceholders();

  for (Entry<String, PlaceholderHook> hook : hooks.entrySet()) {
    PlaceholderHook i = hook.getValue();

    if (i instanceof PlaceholderExpansion) {
      PlaceholderExpansion ex = (PlaceholderExpansion) i;

      if (ex.getRequiredPlugin() == null) {
        continue;
      }

      if (ex.getRequiredPlugin().equalsIgnoreCase(n)) {
        if (PlaceholderAPI.unregisterExpansion(ex)) {
          plugin.getLogger().info("Unregistered placeholder expansion: " + ex.getIdentifier());
        }
      }
    }
  }
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent event) {
    if (!LWC.ENABLED) {
        return;
    }

    Plugin disabled = event.getPlugin();

    // Removes any modules registered by the disabled plugin
    plugin.getLWC().getModuleLoader().removeModules(disabled);
}
 

public static Database createHikariDatabase(Plugin plugin, PooledDatabaseOptions options, boolean setGlobal) {
    HikariPooledDatabase db = new HikariPooledDatabase(options);
    if (setGlobal) {
        DB.setGlobalDatabase(db);
    }
    plugin.getServer().getPluginManager().registerEvents(new Listener() {
        @EventHandler(ignoreCancelled = true)
        public void onPluginDisable(PluginDisableEvent event) {
            if (event.getPlugin() == plugin) {
                db.close();
            }
        }
    }, plugin);
    return db;
}
 

@EventHandler
public void onPluginDisable(PluginDisableEvent e) {
    Plugin plugin = e.getPlugin();
    PluginHook hook = getActiveHook(plugin);
    if (hook == null) return;
    try {
        hook.onPluginDisable(plugin);
    } catch (Exception e1) {
        this.plugin.logException(new InvalidPluginHookException(e1));
    }
    hook.setPlugin(null);
    activeHooks.remove(hook);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPluginDisable(PluginDisableEvent event)
{
	if (event.getPlugin().equals(plugin))
	{
		closeOpenMenus();
		plugin = null;
	}
}