Java Help Needed [updater]

I know I'm missing something obvious.
Well, obvious to those who have taken java classes.
I'm self taught, and haven't had a teacher or colleague to tell me "no you can't do that".
So any assistance you could provide in locating my problem would be lovely. Thank you.

Here's as far as I can tell where my issue is coming from:​

Code:java

package com.gmail.justisroot.cameramode;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
 
 
import java.util.UUID;
 
import org.bukkit.Location;
import org.bukkit.entity.Entity;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.potion.PotionEffect;
import org.bukkit.util.Vector;
 
import com.gmail.justisroot.cameramode.Updater.UpdateType;
 
public class CameraMode extends JavaPlugin {
 
    //##########################//
    //######- Data Store -######//
    //##########################//
 
    public ArrayList<String> flyplayers = new ArrayList<String>();
    public HashMap<String, Integer> fireticks = new HashMap<String, Integer>();
    public HashMap<String, Integer> breath = new HashMap<String, Integer>();
    public ArrayList<String> pause = new ArrayList<String>();
    public List<String> allowedcmds = getConfig().getStringList("CameraMode.PlayersInCM.AllowedCommands");
    public HashMap<String, Location> locations = new HashMap<String, Location>();
    public ArrayList<String> tre = new ArrayList<String>();
    public HashMap<String, List<PotionEffect>> effects = new HashMap<String, List<PotionEffect>>();
    public HashMap<String, Vector> vel = new HashMap<String, Vector>();
    public HashMap<String, Entity> mobs = new HashMap<String, Entity>();
    public HashMap<String, Integer> pvpTimer = new HashMap<String, Integer>();
    public HashMap<String, Float> falldistance = new HashMap<String, Float>();
    public HashMap<UUID, Integer> coolDown = new HashMap<UUID, Integer>();
 
    //###### - Objects - ######//
 
 
    String reason = "You are in CameraMode!";
    UpdateType bifff;
    UpdateType biff = this.getUpdater();
 
    public ArrayList<String> commands = new ArrayList<String>();
 
 
    //############################//
    //#########- Start - #########//
    //############################//
 
    public void onEnable() {
        getConfig().options().copyHeader(true);
        getConfig().options().copyDefaults(true);
        saveConfig();
        if (getConfig().getBoolean("CameraMode.Enabled") == false) {
            getLogger().info("Plugin Disable Setting Detected...");
            getServer().getPluginManager().disablePlugin(this);
        }
        getServer().getPluginManager().registerEvents(new Events(this), this);
        PluginDescriptionFile pdfFile = this.getDescription();
        commands.add("camera");
        commands.add("cameramode");
        for (String commands : this.commands){
            getCommand(commands).setExecutor(new Commands(this));
        }
        getLogger().info(pdfFile.getName() + " v" + pdfFile.getVersion() + " has been enabled");
        if (biff != null) {
        @SuppressWarnings("unused")
        Updater updater = new Updater(this, 80542, getFile(), biff, true);
        }
    }
    public void onDisable(){
        reloadConfig();
        PluginDescriptionFile pdfFile = this.getDescription();
        getLogger().info(pdfFile.getName() + " v" + pdfFile.getVersion() + " has been disabled");
 
    }
 
    //#############################//
    //########- Booleans -#########//
    //#############################//
 
    public boolean commandIsWhitelisted(String playerCmd) {
        playerCmd = playerCmd.replace("/", "");
        for(String allowedCmd : this.allowedcmds) {
                allowedCmd = allowedCmd.replace("/", "");
                if(playerCmd.startsWith(allowedCmd)) return true;
        }
        return false;
    }
    public boolean isInt(String s) {
        try {
            Integer.parseInt(s);
        } catch (NumberFormatException nfe) {
            return false;
        }
        return true;
    }
  //####################################################################################
  //#######      THIS    ##############################################################
  //            VVVVVV
 
    @SuppressWarnings("unused")
    public UpdateType getUpdater(){
        if (getConfig().getBoolean("CameraMode.Updates.AutoUpdate") == true){
            UpdateType bifff = Updater.UpdateType.DEFAULT;
        }else if (getConfig().getBoolean("CameraMode.Updates.NotifyOps") == true){
            UpdateType bifff = Updater.UpdateType.NO_DOWNLOAD;
        }else{
            UpdateType bifff = null;
        }
        return bifff;
    }
}

And...​

Code:java

 
    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent e){
        if (main.biff.equals(Updater.UpdateResult.UPDATE_AVAILABLE)) {
            if (updater.getLatestType().toString().equalsIgnoreCase("release") && (main.getConfig().getBoolean("CameraMode.Updates.NotifyOps") == true)) {
                if (e.getPlayer().hasPermission("cameramode.update")){
                    e.getPlayer().sendMessage(ChatColor.DARK_AQUA + "CameraMode: " + ChatColor.AQUA + "New Update Available!");
                    e.getPlayer().sendMessage(ChatColor.GRAY + updater.getLatestFileLink().toString());
                }
            }
        }
    }

​

Perhaps I'm just getting the information incorrectly... But I suspect it's something to do with the system I've made for determining update availability in the main class...

I'd rather someone help me find the problem and help me to understand why it's not working rather than just be pointed to an answer that works.
Thank you for your time. ​

 

xYourFreindx
Your Updater class?

xYourFreindx
Oh thought you made your own Updater of somesort.
If you refer to this post: http://forums.bukkit.org/threads/up...ant-auto-updating-for-your-plugins-new.96681/

You can find out how to use it. It is litterally one line to check and update the plugin.

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Of course... Sorry.
I'm using the latest of one of dev.bukkit's provided updater classes.
​

Code:java

package com.gmail.justisroot.cameramode;
 
 
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Enumeration;
import java.util.logging.Level;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
 
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.plugin.Plugin;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
 
/**
* Check dev.bukkit.org to find updates for a given plugin, and download the updates if needed.
* <p/>
* <b>VERY, VERY IMPORTANT</b>: Because there are no standards for adding auto-update toggles in your plugin's config, this system provides NO CHECK WITH YOUR CONFIG to make sure the user has allowed auto-updating.
* <br>
* It is a <b>BUKKIT POLICY</b> that you include a boolean value in your config that prevents the auto-updater from running <b>AT ALL</b>.
* <br>
* If you fail to include this option in your config, your plugin will be <b>REJECTED</b> when you attempt to submit it to dev.bukkit.org.
* <p/>
* An example of a good configuration option would be something similar to 'auto-update: true' - if this value is set to false you may NOT run the auto-updater.
* <br>
* If you are unsure about these rules, please read the plugin submission guidelines: [url]http://goo.gl/8iU5l[/url]
*
* @author Gravity
* @version 2.1
*/
 
public class Updater{
 
    private Plugin plugin;
    private UpdateType type;
    private String versionName;
    private String versionLink;
    private String versionType;
    private String versionGameVersion;
 
    private boolean announce; // Whether to announce file downloads
 
    private URL url; // Connecting to RSS
    public File file; // The plugin's file
    private Thread thread; // Updater thread
 
    private int id = -1; // Project's Curse ID
    private String apiKey = null; // BukkitDev ServerMods API key
    private static final String TITLE_VALUE = "name"; // Gets remote file's title
    private static final String LINK_VALUE = "downloadUrl"; // Gets remote file's download link
    private static final String TYPE_VALUE = "releaseType"; // Gets remote file's release type
    private static final String VERSION_VALUE = "gameVersion"; // Gets remote file's build version
    private static final String QUERY = "/servermods/files?projectIds="; // Path to GET
    private static final String HOST = "[url]https://api.curseforge.com[/url]"; // Slugs will be appended to this to get to the project's RSS feed
 
    private static final String USER_AGENT = "Updater (by Gravity)";
    private static final String delimiter = "^v|[\\s_-]v"; // Used for locating version numbers in file names
    private static final String[] NO_UPDATE_TAG = { "-DEV", "-PRE", "-SNAPSHOT" }; // If the version number contains one of these, don't update.
    private static final int BYTE_SIZE = 1024; // Used for downloading files
    private final YamlConfiguration config = new YamlConfiguration(); // Config file
    public String updateFolder;// The folder that downloads will be placed in
    private Updater.UpdateResult result = Updater.UpdateResult.SUCCESS; // Used for determining the outcome of the update process
 
 
    /**
    * Gives the developer the result of the update process. Can be obtained by called {@link #getResult()}
    */
    public enum UpdateResult {
        /**
        * The updater found an update, and has readied it to be loaded the next time the server restarts/reloads.
        */
        SUCCESS,
        /**
        * The updater did not find an update, and nothing was downloaded.
        */
        NO_UPDATE,
        /**
        * The server administrator has disabled the updating system.
        */
        DISABLED,
        /**
        * The updater found an update, but was unable to download it.
        */
        FAIL_DOWNLOAD,
        /**
        * For some reason, the updater was unable to contact dev.bukkit.org to download the file.
        */
        FAIL_DBO,
        /**
        * When running the version check, the file on DBO did not contain a recognizable version.
        */
        FAIL_NOVERSION,
        /**
        * The id provided by the plugin running the updater was invalid and doesn't exist on DBO.
        */
        FAIL_BADID,
        /**
        * The server administrator has improperly configured their API key in the configuration.
        */
        FAIL_APIKEY,
        /**
        * The updater found an update, but because of the UpdateType being set to NO_DOWNLOAD, it wasn't downloaded.
        */
        UPDATE_AVAILABLE
    }
 
    /**
    * Allows the developer to specify the type of update that will be run.
    */
    public enum UpdateType {
        /**
        * Run a version check, and then if the file is out of date, download the newest version.
        */
        DEFAULT,
        /**
        * Don't run a version check, just find the latest update and download it.
        */
        NO_VERSION_CHECK,
        /**
        * Get information about the version and the download size, but don't actually download anything.
        */
        NO_DOWNLOAD
    }
 
    /**
    * Represents the various release types of a file on BukkitDev.
    */
    public enum ReleaseType {
        /**
        * An "alpha" file.
        */
        ALPHA,
        /**
        * A "beta" file.
        */
        BETA,
        /**
        * A "release" file.
        */
        RELEASE
    }
 
    /**
    * Initialize the updater.
    *
    * @param plugin  The plugin that is checking for an update.
    * @param id      The dev.bukkit.org id of the project.
    * @param file    The file that the plugin is running from, get this by doing this.getFile() from within your main class.
    * @param type    Specify the type of update this will be. See {@link UpdateType}
    * @param announce True if the program should announce the progress of new updates in console.
    */
    public Updater(Plugin plugin, int id, File file, UpdateType type, boolean announce) {
        this.plugin = plugin;
        this.type = type;
        this.announce = announce;
        this.file = file;
        this.id = id;
        this.updateFolder = plugin.getServer().getUpdateFolder();
 
        final File pluginFile = plugin.getDataFolder().getParentFile();
        final File updaterFile = new File(pluginFile, "Updater");
        final File updaterConfigFile = new File(updaterFile, "config.yml");
 
        this.config.options().header("This configuration file affects all plugins using the Updater system (version 2+ - [url]http://forums.bukkit.org/threads/96681/[/url] )" + '\n'
                + "If you wish to use your API key, read [url]http://wiki.bukkit.org/ServerMods_API[/url] and place it below." + '\n'
                + "Some updating systems will not adhere to the disabled value, but these may be turned off in their plugin's configuration.");
        this.config.addDefault("api-key", "PUT_API_KEY_HERE");
        this.config.addDefault("disable", false);
 
        if (!updaterFile.exists()) {
            updaterFile.mkdir();
        }
 
        boolean createFile = !updaterConfigFile.exists();
        try {
            if (createFile) {
                updaterConfigFile.createNewFile();
                this.config.options().copyDefaults(true);
                this.config.save(updaterConfigFile);
            } else {
                this.config.load(updaterConfigFile);
            }
        } catch (final Exception e) {
            if (createFile) {
                plugin.getLogger().severe("The updater could not create configuration at " + updaterFile.getAbsolutePath());
            } else {
                plugin.getLogger().severe("The updater could not load configuration at " + updaterFile.getAbsolutePath());
            }
            plugin.getLogger().log(Level.SEVERE, null, e);
        }
 
        if (this.config.getBoolean("disable")) {
            this.result = UpdateResult.DISABLED;
            return;
        }
 
        String key = this.config.getString("api-key");
        if (key.equalsIgnoreCase("PUT_API_KEY_HERE") || key.equals("")) {
            key = null;
        }
 
        this.apiKey = key;
 
        try {
            this.url = new URL(Updater.HOST + Updater.QUERY + id);
        } catch (final MalformedURLException e) {
            plugin.getLogger().log(Level.SEVERE, "The project ID provided for updating, " + id + " is invalid.", e);
            this.result = UpdateResult.FAIL_BADID;
        }
 
        this.thread = new Thread(new UpdateRunnable());
        this.thread.start();
    }
 
    /**
    * Get the result of the update process.
    *
    * @return result of the update process.
    * @see UpdateResult
    */
    public Updater.UpdateResult getResult() {
        this.waitForThread();
        return this.result;
    }
 
    /**
    * Get the latest version's release type.
    *
    * @return latest version's release type.
    * @see ReleaseType
    */
    public ReleaseType getLatestType() {
        this.waitForThread();
        if (this.versionType != null) {
            for (ReleaseType type : ReleaseType.values()) {
                if (this.versionType.equals(type.name().toLowerCase())) {
                    return type;
                }
            }
        }
        return null;
    }
 
    /**
    * Get the latest version's game version (such as "CB 1.2.5-R1.0").
    *
    * @return latest version's game version.
    */
    public String getLatestGameVersion() {
        this.waitForThread();
        return this.versionGameVersion;
    }
 
    /**
    * Get the latest version's name (such as "Project v1.0").
    *
    * @return latest version's name.
    */
    public String getLatestName() {
        this.waitForThread();
        return this.versionName;
    }
 
    /**
    * Get the latest version's direct file link.
    *
    * @return latest version's file link.
    */
    public String getLatestFileLink() {
        this.waitForThread();
        return this.versionLink;
    }
 
    /**
    * As the result of Updater output depends on the thread's completion, it is necessary to wait for the thread to finish
    * before allowing anyone to check the result.
    */
    private void waitForThread() {
        if ((this.thread != null) && this.thread.isAlive()) {
            try {
                this.thread.join();
            } catch (final InterruptedException e) {
                plugin.getLogger().log(Level.SEVERE, null, e);
            }
        }
    }
 
    /**
    * Save an update from dev.bukkit.org into the server's update folder.
    *
    * @param folder the updates folder location.
    * @param file the name of the file to save it as.
    * @param link the url of the file.
    */
    public void saveFile(File folder, String file, String link) {
        if (!folder.exists()) {
            folder.mkdir();
        }
        BufferedInputStream in = null;
        FileOutputStream fout = null;
        try {
            // Download the file
            final URL url = new URL(link);
            final int fileLength = url.openConnection().getContentLength();
            in = new BufferedInputStream(url.openStream());
            fout = new FileOutputStream(folder.getAbsolutePath() + File.separator + file);
 
            final byte[] data = new byte[Updater.BYTE_SIZE];
            int count;
            if (this.announce) {
                this.plugin.getLogger().info("About to download a new update: " + this.versionName);
            }
            long downloaded = 0;
            while ((count = in.read(data, 0, Updater.BYTE_SIZE)) != -1) {
                downloaded += count;
                fout.write(data, 0, count);
                final int percent = (int) ((downloaded * 100) / fileLength);
                if (this.announce && ((percent % 10) == 0)) {
                    this.plugin.getLogger().info("Downloading update: " + percent + "% of " + fileLength + " bytes.");
                }
            }
            //Just a quick check to make sure we didn't leave any files from last time...
            for (final File xFile : new File(this.plugin.getDataFolder().getParent(), this.updateFolder).listFiles()) {
                if (xFile.getName().endsWith(".zip")) {
                    xFile.delete();
                }
            }
            // Check to see if it's a zip file, if it is, unzip it.
            final File dFile = new File(folder.getAbsolutePath() + File.separator + file);
            if (dFile.getName().endsWith(".zip")) {
                // Unzip
                this.unzip(dFile.getCanonicalPath());
            }
            if (this.announce) {
                this.plugin.getLogger().info("Finished updating.");
            }
        } catch (final Exception ex) {
            this.plugin.getLogger().warning("The auto-updater tried to download a new update, but was unsuccessful.");
            this.result = Updater.UpdateResult.FAIL_DOWNLOAD;
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (fout != null) {
                    fout.close();
                }
            } catch (final Exception ex) {
            }
        }
    }
 
    /**
    * Part of Zip-File-Extractor, modified by Gravity for use with Updater.
    *
    * @param file the location of the file to extract.
    */
    private void unzip(String file) {
        try {
            final File fSourceZip = new File(file);
            final String zipPath = file.substring(0, file.length() - 4);
            ZipFile zipFile = new ZipFile(fSourceZip);
            Enumeration<? extends ZipEntry> e = zipFile.entries();
            while (e.hasMoreElements()) {
                ZipEntry entry = e.nextElement();
                File destinationFilePath = new File(zipPath, entry.getName());
                destinationFilePath.getParentFile().mkdirs();
                if (entry.isDirectory()) {
                    continue;
                } else {
                    final BufferedInputStream bis = new BufferedInputStream(zipFile.getInputStream(entry));
                    int b;
                    final byte buffer[] = new byte[Updater.BYTE_SIZE];
                    final FileOutputStream fos = new FileOutputStream(destinationFilePath);
                    final BufferedOutputStream bos = new BufferedOutputStream(fos, Updater.BYTE_SIZE);
                    while ((b = bis.read(buffer, 0, Updater.BYTE_SIZE)) != -1) {
                        bos.write(buffer, 0, b);
                    }
                    bos.flush();
                    bos.close();
                    bis.close();
                    final String name = destinationFilePath.getName();
                    if (name.endsWith(".jar") && this.pluginFile(name)) {
                        destinationFilePath.renameTo(new File(this.plugin.getDataFolder().getParent(), this.updateFolder + File.separator + name));
                    }
                }
                entry = null;
                destinationFilePath = null;
            }
            e = null;
            zipFile.close();
            zipFile = null;
 
            // Move any plugin data folders that were included to the right place, Bukkit won't do this for us.
            for (final File dFile : new File(zipPath).listFiles()) {
                if (dFile.isDirectory()) {
                    if (this.pluginFile(dFile.getName())) {
                        final File oFile = new File(this.plugin.getDataFolder().getParent(), dFile.getName()); // Get current dir
                        final File[] contents = oFile.listFiles(); // List of existing files in the current dir
                        for (final File cFile : dFile.listFiles()) // Loop through all the files in the new dir
                        {
                            boolean found = false;
                            for (final File xFile : contents) // Loop through contents to see if it exists
                            {
                                if (xFile.getName().equals(cFile.getName())) {
                                    found = true;
                                    break;
                                }
                            }
                            if (!found) {
                                // Move the new file into the current dir
                                cFile.renameTo(new File(oFile.getCanonicalFile() + File.separator + cFile.getName()));
                            } else {
                                // This file already exists, so we don't need it anymore.
                                cFile.delete();
                            }
                        }
                    }
                }
                dFile.delete();
            }
            new File(zipPath).delete();
            fSourceZip.delete();
        } catch (final IOException e) {
            this.plugin.getLogger().log(Level.SEVERE, "The auto-updater tried to unzip a new update file, but was unsuccessful.", e);
            this.result = Updater.UpdateResult.FAIL_DOWNLOAD;
        }
        new File(file).delete();
    }
 
 
    /**
    * Check if the name of a jar is one of the plugins currently installed, used for extracting the correct files out of a zip.
    *
    * @param name a name to check for inside the plugins folder.
    * @return true if a file inside the plugins folder is named this.
    */
    private boolean pluginFile(String name) {
        for (final File file : new File("plugins").listFiles()) {
            if (file.getName().equals(name)) {
                return true;
            }
        }
        return false;
    }
    /**
    * Check to see if the program should continue by evaluating whether the plugin is already updated, or shouldn't be updated.
    *
    * @param title the plugin's title.
    * @return true if the version was located and is not the same as the remote's newest.
    */
    private boolean versionCheck(String title) {
        if (this.type != UpdateType.NO_VERSION_CHECK) {
            final String localVersion = this.plugin.getDescription().getVersion();
            if (title.split(delimiter).length == 2) {
                final String remoteVersion = title.split(delimiter)[1].split(" ")[0]; // Get the newest file's version number
 
                if (this.hasTag(localVersion) || !this.shouldUpdate(localVersion, remoteVersion)) {
                    // We already have the latest version, or this build is tagged for no-update
                    this.result = Updater.UpdateResult.NO_UPDATE;
                    return false;
                }
            } else {
                // The file's name did not contain the string 'vVersion'
                final String authorInfo = this.plugin.getDescription().getAuthors().size() == 0 ? "" : " (" + this.plugin.getDescription().getAuthors().get(0) + ")";
                this.plugin.getLogger().warning("The author of this plugin" + authorInfo + " has misconfigured their Auto Update system");
                this.plugin.getLogger().warning("File versions should follow the format 'PluginName vVERSION'");
                this.plugin.getLogger().warning("Please notify the author of this error.");
                this.result = Updater.UpdateResult.FAIL_NOVERSION;
                return false;
            }
        }
        return true;
    }
    /**
    * <b>If you wish to run mathematical versioning checks, edit this method.</b>
    * <p>
    * With default behavior, Updater will NOT verify that a remote version available on BukkitDev
    * which is not this version is indeed an "update".
    * If a version is present on BukkitDev that is not the version that is currently running,
    * Updater will assume that it is a newer version.
    * This is because there is no standard versioning scheme, and creating a calculation that can
    * determine whether a new update is actually an update is sometimes extremely complicated.
    * </p>
    * <p>
    * Updater will call this method from {@link #versionCheck(String)} before deciding whether
    * the remote version is actually an update.
    * If you have a specific versioning scheme with which a mathematical determination can
    * be reliably made to decide whether one version is higher than another, you may
    * revise this method, using the local and remote version parameters, to execute the
    * appropriate check.
    * </p>
    * <p>
    * Returning a value of <b>false</b> will tell the update process that this is NOT a new version.
    * Without revision, this method will always consider a remote version at all different from
    * that of the local version a new update.
    * </p>
    * @param localVersion the current version
    * @param remoteVersion the remote version
    * @return true if Updater should consider the remote version an update, false if not.
    */
    public boolean shouldUpdate(String localVersion, String remoteVersion) {
        return !localVersion.equalsIgnoreCase(remoteVersion);
    }
    /**
    * Evaluate whether the version number is marked showing that it should not be updated by this program.
    *
    * @param version a version number to check for tags in.
    * @return true if updating should be disabled.
    */
    private boolean hasTag(String version) {
        for (final String string : Updater.NO_UPDATE_TAG) {
            if (version.contains(string)) {
                return true;
            }
        }
        return false;
    }
    /**
    * Make a connection to the BukkitDev API and request the newest file's details.
    *
    * @return true if successful.
    */
    private boolean read() {
        try {
            final URLConnection conn = this.url.openConnection();
            conn.setConnectTimeout(5000);
            if (this.apiKey != null) {
                conn.addRequestProperty("X-API-Key", this.apiKey);
            }
            conn.addRequestProperty("User-Agent", Updater.USER_AGENT);
            conn.setDoOutput(true);
            final BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            final String response = reader.readLine();
            final JSONArray array = (JSONArray) JSONValue.parse(response);
            if (array.size() == 0) {
                this.plugin.getLogger().warning("The updater could not find any files for the project id " + this.id);
                this.result = UpdateResult.FAIL_BADID;
                return false;
            }
            this.versionName = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.TITLE_VALUE);
            this.versionLink = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.LINK_VALUE);
            this.versionType = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.TYPE_VALUE);
            this.versionGameVersion = (String) ((JSONObject) array.get(array.size() - 1)).get(Updater.VERSION_VALUE);
            return true;
        } catch (final IOException e) {
            if (e.getMessage().contains("HTTP response code: 403")) {
                this.plugin.getLogger().severe("dev.bukkit.org rejected the API key provided in plugins/Updater/config.yml");
                this.plugin.getLogger().severe("Please double-check your configuration to ensure it is correct.");
                this.result = UpdateResult.FAIL_APIKEY;
            } else {
                this.plugin.getLogger().severe("The updater could not contact dev.bukkit.org for updating.");
                this.plugin.getLogger().severe("If you have not recently modified your configuration and this is the first time you are seeing this message, the site may be experiencing temporary downtime.");
                this.result = UpdateResult.FAIL_DBO;
            }
            return false;
        }
    }
    private class UpdateRunnable implements Runnable {
        @Override
        public void run() {
            if (Updater.this.url != null) {
                // Obtain the results of the project's file feed
                if (Updater.this.read()) {
                    if (Updater.this.versionCheck(Updater.this.versionName)) {
                        if ((Updater.this.versionLink != null) && (Updater.this.type != UpdateType.NO_DOWNLOAD)) {
                            String name = Updater.this.file.getName();
                            // If it's a zip file, it shouldn't be downloaded as the plugin's name
                            if (Updater.this.versionLink.endsWith(".zip")) {
                                final String[] split = Updater.this.versionLink.split("/");
                                name = split[split.length - 1];
                            }
                            Updater.this.saveFile(new File(Updater.this.plugin.getDataFolder().getParent(), Updater.this.updateFolder), name, Updater.this.versionLink);
                        } else {
                            Updater.this.result = UpdateResult.UPDATE_AVAILABLE;
                        }
                    }
                }
            }
        }
    }
}
 

​

 

xYourFreindx lines 29 and 44 should be moved to onEnable. You cannot use the config before onEnable (could be onLoad, not entirely sure)

 

Gater12 Nonono... I know how to use it. I've used it before. But I can't just use one line if I want it to be accepted by the bukkit staff for upload to dev.bukkit.

If you hadn't noticed, I've got three options.
You can...
Have the plugin autoUpdate,
Have the plugin notify you that there is an update available.
Or have it do nothing.

That's basically what I'm trying to do here.
I had it working on an earlier version. But it still instantiated the updater class (even though it didn't do anything), and it was rejected. This is what I'm trying to remedy here. And my question was... Why is my system not working?

 

If you want it to meet standards there just needs to be a way to disable it

 

1Rogue
I submitted the plugin with the option to disable updating and notifying for updates, but it still checked (in the background). It was rejected.

An option to disable it completely is what I'm trying to do here. That's the purpose.

 

xYourFreindx Not sure on why you sent me the PM as im not fully aware of your error, is there any Stack Trace or something that is failing?

 

If all you need to do is make the auto-update configurable:

Before the "check update" line (whatever that code actually is), you can do:

Code:java

if(getConfig().getBoolean("autoupdate") {
// check for updates
}

Off-topic: seriously, the amount of publics in that class hurts my eyes, please Google and read about why we encapsulate data. Furthermore, learn about Upper and lowerCamelCase, and what they identify and why they are used in code.

 

DevRosemberg Not really.
It just throws a NPE whenever someone joins.

As I said in my original post, I think it might be my system for determining the updater settings, but I'm not sure how to improve it.