Change message & timeout task to run synchronously.

src/main/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommand.java

@@ -1,14 +1,5 @@
 package fr.xephi.authme.command.executable.authme;
 
-import java.util.List;
-
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.bukkit.scheduler.BukkitTask;
-
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.cache.auth.PlayerCache;
@@ -20,6 +11,14 @@ import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.task.MessageTask;
 import fr.xephi.authme.task.TimeoutTask;
 import fr.xephi.authme.util.Utils;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.List;
 
 /**
  * Admin command to unregister a player.
@@ -55,19 +54,20 @@ public class UnregisterAdminCommand implements ExecutableCommand {
         if (target != null && target.isOnline()) {
             Utils.teleportToSpawn(target);
             LimboCache.getInstance().addLimboPlayer(target);
-            int delay = Settings.getRegistrationTimeout * 20;
+            int timeOut = Settings.getRegistrationTimeout * 20;
             int interval = Settings.getWarnMessageInterval;
             BukkitScheduler scheduler = sender.getServer().getScheduler();
-            if (delay != 0) {
+            if (timeOut != 0) {
-                BukkitTask id = scheduler.runTaskLaterAsynchronously(plugin, new TimeoutTask(plugin, playerNameLowerCase, target), delay);
+                BukkitTask id = scheduler.runTaskLater(plugin, new TimeoutTask(plugin, playerNameLowerCase, target), timeOut);
                 LimboCache.getInstance().getLimboPlayer(playerNameLowerCase).setTimeoutTaskId(id);
             }
             LimboCache.getInstance().getLimboPlayer(playerNameLowerCase).setMessageTaskId(
-                scheduler.runTaskAsynchronously(plugin,
+                scheduler.runTask(
-                    new MessageTask(plugin, playerNameLowerCase, commandService.retrieveMessage(MessageKey.REGISTER_MESSAGE), interval)));
+                    plugin, new MessageTask(plugin, playerNameLowerCase, MessageKey.REGISTER_MESSAGE, interval)
+                )
+            );
             if (Settings.applyBlindEffect) {
-                target.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS,
+                target.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
-                    Settings.getRegistrationTimeout * 20, 2));
             }
             commandService.send(target, MessageKey.UNREGISTERED_SUCCESS);
         }

src/main/java/fr/xephi/authme/process/join/AsynchronousJoin.java

@@ -205,20 +205,20 @@ public class AsynchronousJoin {
 
         int msgInterval = Settings.getWarnMessageInterval;
         if (timeOut > 0) {
-            BukkitTask id = sched.runTaskLaterAsynchronously(plugin, new TimeoutTask(plugin, name, player), timeOut);
+            BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut);
             LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id);
         }
 
-        String[] msg;
+        MessageKey msg;
         if (isAuthAvailable) {
-            msg = m.retrieve(MessageKey.LOGIN_MESSAGE);
+            msg = MessageKey.LOGIN_MESSAGE;
         } else {
             msg = Settings.emailRegistration
-                ? m.retrieve(MessageKey.REGISTER_EMAIL_MESSAGE)
+                ? MessageKey.REGISTER_EMAIL_MESSAGE
-                : m.retrieve(MessageKey.REGISTER_MESSAGE);
+                : MessageKey.REGISTER_MESSAGE;
         }
         if (msgInterval > 0 && LimboCache.getInstance().getLimboPlayer(name) != null) {
-            BukkitTask msgTask = sched.runTaskAsynchronously(plugin, new MessageTask(plugin, name, msg, msgInterval));
+            BukkitTask msgTask = sched.runTask(plugin, new MessageTask(plugin, name, msg, msgInterval));
             LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgTask);
         }
     }

src/main/java/fr/xephi/authme/process/login/AsynchronousLogin.java

@@ -105,7 +105,7 @@ public class AsynchronousLogin {
                 } else {
                     msg = m.retrieve(MessageKey.REGISTER_MESSAGE);
                 }
-                BukkitTask msgT = Bukkit.getScheduler().runTaskAsynchronously(plugin,
+                BukkitTask msgT = Bukkit.getScheduler().runTask(plugin,
                     new MessageTask(plugin, name, msg, settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)));
                 LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgT);
             }

src/main/java/fr/xephi/authme/process/logout/ProcessSyncronousPlayerLogout.java

@@ -74,21 +74,24 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
         int interval = Settings.getWarnMessageInterval;
         BukkitScheduler sched = player.getServer().getScheduler();
         if (timeOut != 0) {
-            BukkitTask id = sched.runTaskLaterAsynchronously(plugin, new TimeoutTask(plugin, name, player), timeOut);
+            BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut);
             LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id);
         }
-        BukkitTask msgT = sched.runTaskAsynchronously(plugin, new MessageTask(plugin, name, m.retrieve(MessageKey.LOGIN_MESSAGE), interval));
+        BukkitTask msgT = sched.runTask(plugin, new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval));
         LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgT);
-        if (player.isInsideVehicle() && player.getVehicle() != null)
+        if (player.isInsideVehicle() && player.getVehicle() != null) {
             player.getVehicle().eject();
-        if (Settings.applyBlindEffect)
+        }
-            player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, Settings.getRegistrationTimeout * 20, 2));
+        if (Settings.applyBlindEffect) {
+            player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
+        }
         player.setOp(false);
         restoreSpeedEffect();
         // Player is now logout... Time to fire event !
         Bukkit.getServer().getPluginManager().callEvent(new LogoutEvent(player));
-        if (Settings.bungee)
+        if (Settings.bungee) {
             sendBungeeMessage();
+        }
         m.send(player, MessageKey.LOGOUT_SUCCESS);
         ConsoleLogger.info(player.getName() + " logged out");
     }

src/main/java/fr/xephi/authme/process/quit/AsynchronousQuit.java

@@ -7,32 +7,23 @@ import fr.xephi.authme.cache.limbo.LimboCache;
 import fr.xephi.authme.cache.limbo.LimboPlayer;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.util.StringUtils;
 import fr.xephi.authme.util.Utils;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
 
-/**
- */
 public class AsynchronousQuit {
 
-    protected final AuthMe plugin;
+    private final AuthMe plugin;
-    protected final DataSource database;
+    private final DataSource database;
-    protected final Player player;
+    private final Player player;
     private final String name;
     private boolean isOp = false;
     private boolean needToChange = false;
     private boolean isKick = false;
 
-    /**
-     * Constructor for AsynchronousQuit.
-     *
-     * @param p        Player
-     * @param plugin   AuthMe
-     * @param database DataSource
-     * @param isKick   boolean
-     */
     public AsynchronousQuit(Player p, AuthMe plugin, DataSource database,
                             boolean isKick) {
         this.player = p;
@@ -43,9 +34,7 @@ public class AsynchronousQuit {
     }
 
     public void process() {
-        if (player == null)
+        if (player == null || Utils.isUnrestricted(player)) {
-            return;
-        if (Utils.isUnrestricted(player)) {
             return;
         }
 
@@ -54,7 +43,9 @@ public class AsynchronousQuit {
         if (PlayerCache.getInstance().isAuthenticated(name)) {
             if (Settings.isSaveQuitLocationEnabled) {
                 Location loc = player.getLocation();
-                PlayerAuth auth = new PlayerAuth(name, loc.getX(), loc.getY(), loc.getZ(), loc.getWorld().getName(), player.getName());
+                PlayerAuth auth = PlayerAuth.builder()
+                    .name(name).location(loc)
+                    .realName(player.getName()).build();
                 database.updateQuitLoc(auth);
             }
             PlayerAuth auth = new PlayerAuth(name, ip, System.currentTimeMillis(), player.getName());
@@ -63,14 +54,11 @@ public class AsynchronousQuit {
 
         LimboPlayer limbo = LimboCache.getInstance().getLimboPlayer(name);
         if (limbo != null) {
-            if (limbo.getGroup() != null && !limbo.getGroup().isEmpty())
+            if (!StringUtils.isEmpty(limbo.getGroup())) {
                 Utils.addNormal(player, limbo.getGroup());
+            }
             needToChange = true;
             isOp = limbo.getOperator();
-            if (limbo.getTimeoutTaskId() != null)
-                limbo.getTimeoutTaskId().cancel();
-            if (limbo.getMessageTaskId() != null)
-                limbo.getMessageTaskId().cancel();
             LimboCache.getInstance().deleteLimboPlayer(name);
         }
         if (Settings.isSessionsEnabled && !isKick) {
@@ -104,7 +92,6 @@ public class AsynchronousQuit {
 
     private void postLogout() {
         PlayerCache.getInstance().removePlayer(name);
-        if (database.isLogged(name))
         database.setUnlogged(name);
         plugin.sessions.remove(name);
     }

src/main/java/fr/xephi/authme/process/register/ProcessSyncEmailRegister.java

@@ -52,14 +52,13 @@ public class ProcessSyncEmailRegister implements Runnable {
         int msgInterval = Settings.getWarnMessageInterval;
 
         BukkitScheduler sched = plugin.getServer().getScheduler();
-        if (time != 0 && limbo != null) {
+
-            limbo.getTimeoutTaskId().cancel();
+        if (limbo != null) {
-            BukkitTask id = sched.runTaskLaterAsynchronously(plugin, new TimeoutTask(plugin, name, player), time);
+            if (time != 0) {
+                BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), time);
                 limbo.setTimeoutTaskId(id);
             }
-        if (limbo != null) {
+            BukkitTask nwMsg = sched.runTask(plugin, new MessageTask(plugin, name, m.retrieve(MessageKey.LOGIN_MESSAGE), msgInterval));
-            limbo.getMessageTaskId().cancel();
-            BukkitTask nwMsg = sched.runTaskAsynchronously(plugin, new MessageTask(plugin, name, m.retrieve(MessageKey.LOGIN_MESSAGE), msgInterval));
             limbo.setMessageTaskId(nwMsg);
         }
 

src/main/java/fr/xephi/authme/process/register/ProcessSyncPasswordRegister.java

@@ -1,16 +1,7 @@
 package fr.xephi.authme.process.register;
 
-import fr.xephi.authme.settings.NewSetting;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.bukkit.scheduler.BukkitTask;
-
 import com.google.common.io.ByteArrayDataOutput;
 import com.google.common.io.ByteStreams;
-
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.cache.limbo.LimboCache;
@@ -19,10 +10,17 @@ import fr.xephi.authme.events.LoginEvent;
 import fr.xephi.authme.events.RestoreInventoryEvent;
 import fr.xephi.authme.output.MessageKey;
 import fr.xephi.authme.output.Messages;
+import fr.xephi.authme.settings.NewSetting;
 import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.settings.properties.HooksSettings;
 import fr.xephi.authme.task.MessageTask;
 import fr.xephi.authme.task.TimeoutTask;
 import fr.xephi.authme.util.Utils;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.scheduler.BukkitTask;
 
 /**
  */
@@ -77,11 +75,10 @@ public class ProcessSyncPasswordRegister implements Runnable {
         BukkitScheduler sched = plugin.getServer().getScheduler();
         BukkitTask task;
         if (delay != 0) {
-            task = sched.runTaskLaterAsynchronously(plugin, new TimeoutTask(plugin, name, player), delay);
+            task = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), delay);
             cache.getLimboPlayer(name).setTimeoutTaskId(task);
         }
-        task = sched.runTaskAsynchronously(plugin, new MessageTask(plugin, name,
+        task = sched.runTask(plugin, new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval));
-            m.retrieve(MessageKey.LOGIN_MESSAGE), interval));
         cache.getLimboPlayer(name).setMessageTaskId(task);
         if (player.isInsideVehicle() && player.getVehicle() != null) {
             player.getVehicle().eject();

src/main/java/fr/xephi/authme/process/unregister/AsynchronousUnregister.java

@@ -73,12 +73,11 @@ public class AsynchronousUnregister {
                 int interval = Settings.getWarnMessageInterval;
                 BukkitScheduler scheduler = plugin.getServer().getScheduler();
                 if (timeOut != 0) {
-                    BukkitTask id = scheduler.runTaskLaterAsynchronously(plugin,
+                    BukkitTask id = scheduler.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut);
-                        new TimeoutTask(plugin, name, player), timeOut);
                     limboPlayer.setTimeoutTaskId(id);
                 }
-                limboPlayer.setMessageTaskId(scheduler.runTaskAsynchronously(plugin,
+                limboPlayer.setMessageTaskId(scheduler.runTask(plugin,
-                        new MessageTask(plugin, name, m.retrieve(MessageKey.REGISTER_MESSAGE), interval)));
+                    new MessageTask(plugin, name, MessageKey.REGISTER_MESSAGE, interval)));
                 m.send(player, MessageKey.UNREGISTERED_SUCCESS);
                 ConsoleLogger.info(player.getDisplayName() + " unregistered himself");
                 return;

src/main/java/fr/xephi/authme/task/MessageTask.java

@@ -3,6 +3,7 @@ package fr.xephi.authme.task;
 import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.cache.limbo.LimboCache;
+import fr.xephi.authme.output.MessageKey;
 import fr.xephi.authme.util.Utils;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
@@ -24,32 +25,31 @@ public class MessageTask implements Runnable {
      * @param strings  String[]
      * @param interval int
      */
-    public MessageTask(AuthMe plugin, String name, String[] strings,
+    public MessageTask(AuthMe plugin, String name, String[] strings, int interval) {
-                       int interval) {
         this.plugin = plugin;
         this.name = name;
         this.msg = strings;
         this.interval = interval;
     }
 
-    /**
+    public MessageTask(AuthMe plugin, String name, MessageKey messageKey, int interval) {
-     * Method run.
+        this(plugin, name, plugin.getMessages().retrieve(messageKey), interval);
-     *
+    }
-     * @see java.lang.Runnable#run()
+
-     */
     @Override
     public void run() {
-        if (PlayerCache.getInstance().isAuthenticated(name))
+        if (PlayerCache.getInstance().isAuthenticated(name)) {
             return;
+        }
 
         for (Player player : Utils.getOnlinePlayers()) {
-            if (player.getName().toLowerCase().equals(name)) {
+            if (player.getName().equalsIgnoreCase(name)) {
                 for (String ms : msg) {
                     player.sendMessage(ms);
                 }
-                BukkitTask late = plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, this, interval * 20);
+                BukkitTask nextTask = plugin.getServer().getScheduler().runTaskLater(plugin, this, interval * 20);
                 if (LimboCache.getInstance().hasLimboPlayer(name)) {
-                    LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(late);
+                    LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(nextTask);
                 }
                 return;
             }

src/main/java/fr/xephi/authme/task/TimeoutTask.java

@@ -4,14 +4,10 @@ import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.output.MessageKey;
 import fr.xephi.authme.output.Messages;
-import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
-/**
- */
 public class TimeoutTask implements Runnable {
 
-    private final AuthMe plugin;
     private final String name;
     private final Messages m;
     private final Player player;
@@ -25,38 +21,14 @@ public class TimeoutTask implements Runnable {
      */
     public TimeoutTask(AuthMe plugin, String name, Player player) {
         this.m = plugin.getMessages();
-        this.plugin = plugin;
         this.name = name;
         this.player = player;
     }
 
-    /**
-     * Method getName.
-     *
-     * @return String
-     */
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * Method run.
-     *
-     * @see java.lang.Runnable#run()
-     */
     @Override
     public void run() {
-        if (PlayerCache.getInstance().isAuthenticated(name)) {
+        if (!PlayerCache.getInstance().isAuthenticated(name)) {
-            return;
-        }
-
-        Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
-            @Override
-            public void run() {
-                if (player.isOnline()) {
             player.kickPlayer(m.retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR));
         }
     }
-        });
-    }
 }