Enable a plugin with another plugin

I'm very new to Bukkit plugin Development, and ran into a situation I've had before in Java programming. I never really found the solution however, but now I need it. I have a map voting plugin that needs to start the mini-game plugin when the players are teleported to the map. Is there a way to have the Map Voting plugin call or enable the Mini-game plugin?

 

As for loading and unloading a plugin, you could search up plugins like that and take a peek at their source code using this.

For your convenience, I'll paste it here for you.

Code:java

import java.io.File;
import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.SortedSet;
import java.util.logging.Level;
 
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.PluginCommand;
import org.bukkit.command.SimpleCommandMap;
import org.bukkit.event.Event;
import org.bukkit.plugin.InvalidDescriptionException;
import org.bukkit.plugin.InvalidPluginException;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.RegisteredListener;
import org.bukkit.plugin.UnknownDependencyException;
 
public class Utils {
    public PluginReload plugin;
 
    private static final String SPECIFY_PLUGIN = ChatColor.RED + "Must specify a plugin!";
    private static final String PLUGIN_NOT_FOUND = ChatColor.RED + "Plugin not found!";
 
    public Utils(PluginReload instance) {
        plugin = instance;
    }
 
    public Plugin getPlugin(String p) {
        for (Plugin pl : plugin.getServer().getPluginManager().getPlugins()) {
            if (pl.getDescription().getName().equalsIgnoreCase(p)) {
                return pl;
            }
        }
        return null;
    }
 
    private String consolidateArgs(String[] args) {
        String pl = args[1];
        if (args.length > 2) {
            for (int i = 2; i < args.length; i++) {
                pl = pl + " " + args[i];
            }
        }
        return pl;
    }
 
    public String loadPlugin(String pl) {
        Plugin targetPlugin = null;
        String msg = "";
        File pluginDir = new File("plugins");
        if (!pluginDir.isDirectory()) {
            return (ChatColor.RED + "Plugin directory not found!");
        }
        File pluginFile = new File(pluginDir, pl + ".jar");
        // plugin.getLogger().info("Want: " + pluginFile);
        if (!pluginFile.isFile()) {
            for (File f : pluginDir.listFiles()) {
                try {
                    if (f.getName().endsWith(".jar")) {
                        PluginDescriptionFile pdf = plugin.getPluginLoader().getPluginDescription(f);
                        // plugin.getLogger().info("Searching for " + pl + ": " + f + " -> " + pdf.getName());
                        if (pdf.getName().equalsIgnoreCase(pl)) {
                            pluginFile = f;
                            msg = "(via search) ";
                            break;
                        }
                    }
                } catch (InvalidDescriptionException e) {
                    return (ChatColor.RED + "Couldn't find file and failed to search descriptions!");
                }
            }
        }
        try {
            plugin.getServer().getPluginManager().loadPlugin(pluginFile);
            targetPlugin = getPlugin(pl);
            targetPlugin.onLoad();
            plugin.getServer().getPluginManager().enablePlugin(targetPlugin);
            return (ChatColor.GREEN + "" + getPlugin(pl) + " loaded " + msg + "and enabled!");
        } catch (UnknownDependencyException e) {
            return (ChatColor.RED + "File exists, but is missing a dependency!");
        } catch (InvalidPluginException e) {
            plugin.getLogger().log(Level.SEVERE, "Tried to load invalid Plugin.\n", e);
            return (ChatColor.RED + "File exists, but isn't a loadable plugin file!");
        } catch (InvalidDescriptionException e) {
            return (ChatColor.RED + "Plugin exists, but has an invalid description!");
        }
    }
 
    public String unloadPlugin(String pl) {
 
        PluginManager pm = plugin.getServer().getPluginManager();
        SimpleCommandMap cmdMap = null;
        List<Plugin> plugins = null;
        Map<String, Plugin> names = null;
        Map<String, Command> commands = null;
        Map<Event, SortedSet<RegisteredListener>> listeners = null;
        boolean reloadlisteners = true;
        if (pm != null) {
            try {
                Field pluginsField = plugin.getServer().getPluginManager().getClass().getDeclaredField("plugins");
                pluginsField.setAccessible(true);
                plugins = (List<Plugin>) pluginsField.get(pm);
 
                Field lookupNamesField = plugin.getServer().getPluginManager().getClass().getDeclaredField("lookupNames");
                lookupNamesField.setAccessible(true);
                names = (Map<String, Plugin>) lookupNamesField.get(pm);
 
                try {
                    Field listenersField = plugin.getServer().getPluginManager().getClass().getDeclaredField("listeners");
                    listenersField.setAccessible(true);
                    listeners = (Map<Event, SortedSet<RegisteredListener>>) listenersField.get(pm);
                } catch (Exception e) {
                    reloadlisteners = false;
                }
 
                Field commandMapField = plugin.getServer().getPluginManager().getClass().getDeclaredField("commandMap");
                commandMapField.setAccessible(true);
                cmdMap = (SimpleCommandMap) commandMapField.get(pm);
 
                Field knownCommandsField = cmdMap.getClass().getDeclaredField("knownCommands");
                knownCommandsField.setAccessible(true);
                commands = (Map<String, Command>) knownCommandsField.get(cmdMap);
            } catch (NoSuchFieldException e) {
                return (ChatColor.RED + "Failed to unload plugin!");
            } catch (IllegalAccessException e) {
                return (ChatColor.RED + "Failed to unload plugin!");
            }
        }
 
        String tp = "";
        for (Plugin p : plugin.getServer().getPluginManager().getPlugins()) {
            if (p.getDescription().getName().equalsIgnoreCase(pl)) {
                pm.disablePlugin(p);
                tp += p.getName() + " ";
                if (plugins != null && plugins.contains(p)) {
                    plugins.remove(p);
                }
 
                if (names != null && names.containsKey(pl)) {
                    names.remove(pl);
                }
 
                if (listeners != null && reloadlisteners) {
                    for (SortedSet<RegisteredListener> set : listeners.values()) {
                        for (Iterator<RegisteredListener> it = set.iterator(); it.hasNext();) {
                            RegisteredListener value = it.next();
 
                            if (value.getPlugin() == p) {
                                it.remove();
                            }
                        }
                    }
                }
 
                if (cmdMap != null) {
                    for (Iterator<Map.Entry<String, Command>> it = commands.entrySet().iterator(); it.hasNext();) {
                        Map.Entry<String, Command> entry = it.next();
                        if (entry.getValue() instanceof PluginCommand) {
                            PluginCommand c = (PluginCommand) entry.getValue();
                            if (c.getPlugin() == p) {
                                c.unregister(cmdMap);
                                it.remove();
                            }
                        }
                    }
                }
            }
        }
        return (ChatColor.GREEN + tp + "has been unloaded and disabled!");
    }
 
}[/i]

This is my version of the original, Util.class.

 

Thanks, and by the way, I wrote the plugins. So how would I tell bukkit to not load the mini-game plugin, so that it can be enabled for the first time later on?

 

(Sorry for double-posting. It'd screw up the formatting of the code.)
As for calling methods from another plugin, or at least that's what I think you're referring to, you will need to include it as a reference library in your project, the same way you include bukkit.jar and craftbukkit.jar as reference libraries.

In case you don't know how that works, you are basically referencing the classes and methods from that .jar file.
public non-static methods will have to be called the same way you would with an actual class from your project workspace,
public static methods can be called the same way you would with an actual class from your project workspace, interfaces can be used the same way too.

#EDIT: Just in case you got confused as to what 'PluginReload' is, its the main class of my plugin. So you'd want to replace that with the main class of your plugin.

 

I thought referencing classes from another jar would import those classes into your project, but okay. Thanks for the help!

 

You could disable the plugin with your other plugin using the Util.class that I sourced you. Then, enable it when you want to, by using the same Util.class.

No problem. It does import those classes into your project. Sorry if my explanation was a little confusing, but I guess you already know what that does, so I don't think I need to explain that to you anymore.

 

I had one other problem: When I type Plugin.meth(); for example, it says it can't make a static reference to a non-static method. But when I create a reference variable, Bukkit gives me errors saying that one of the plugins has already been initialized. I don't know exactly which one it's talking about, but I'm assuming that creating a reference to it is reloading the plugin? Any Ideas?

 

Endro32
You could've just done

PHP:

Bukkit.getServer().getPluginManager().enablePlugin(Bukkit.getServer().getPluginManager().getPlugin("PLUGIN NAME"));

 

Endro32 You can check if that second plugin which you want disabled at start is enabled or not. If it isn't, then enable it.

I'm not too sure about that, but when you create a new instance, yeah, it might enable it. I'm not on the computer right now, so I can't give you much or any code. Just to make sure, you DID disable it on start-up by checking if the plugin is present, then disabling it?

 

No, but I will definitely do that. Like I said, I literally started coding Bukkit Plugins like a couple days ago

 

Endro32

Just do it this way..?

 

Disable the other plugin on startup

 

A bit of a stupid trick, but it works (I think?):

Rename the extension to something else (prevents plugin from loading on startup).
Call loadPlugin to load the plugin file.