#723 Create provider for TimeoutTask and MessageTask, remove LimboCache#getInstance

- Create class to handle the creation of "LimboPlayer tasks" (adds encapsulation, reduces duplication)
- Move group setting into its own class because (mutual dependency between LimboCache and PermissionsManager otherwise)

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

@@ -0,0 +1,94 @@
+package fr.xephi.authme.task;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.cache.auth.PlayerCache;
+import fr.xephi.authme.cache.limbo.LimboCache;
+import fr.xephi.authme.cache.limbo.LimboPlayer;
+import fr.xephi.authme.output.MessageKey;
+import fr.xephi.authme.output.Messages;
+import fr.xephi.authme.settings.NewSetting;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
+import fr.xephi.authme.util.BukkitService;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitTask;
+
+import javax.inject.Inject;
+
+import static fr.xephi.authme.util.BukkitService.TICKS_PER_SECOND;
+
+/**
+ * Registers tasks associated with a LimboPlayer.
+ */
+public class LimboPlayerTaskManager {
+
+    @Inject
+    private Messages messages;
+
+    @Inject
+    private NewSetting settings;
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private LimboCache limboCache;
+
+    @Inject
+    private PlayerCache playerCache;
+
+    LimboPlayerTaskManager() { }
+
+
+    /**
+     * Registers a {@link MessageTask} for the given player name.
+     *
+     * @param name the name of the player to schedule a repeating message task for
+     * @param key the key of the message to display
+     */
+    public void registerMessageTask(String name, MessageKey key) {
+        final int interval = settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
+        if (interval > 0) {
+            final LimboPlayer limboPlayer = limboCache.getLimboPlayer(name);
+            if (limboPlayer == null) {
+                ConsoleLogger.info("LimboPlayer for '" + name + "' is not available");
+            } else {
+                cancelTask(limboPlayer.getMessageTask());
+                BukkitTask messageTask = bukkitService.runTask(new MessageTask(name, messages.retrieve(key),
+                    interval, bukkitService, limboCache, playerCache));
+                limboPlayer.setMessageTask(messageTask);
+            }
+        }
+    }
+
+    /**
+     * Registers a {@link TimeoutTask} for the given player according to the configuration.
+     *
+     * @param player the player to register a timeout task for
+     */
+    public void registerTimeoutTask(Player player) {
+        final int timeout = settings.getProperty(RestrictionSettings.TIMEOUT) * TICKS_PER_SECOND;
+        if (timeout > 0) {
+            final LimboPlayer limboPlayer = limboCache.getLimboPlayer(player.getName());
+            if (limboPlayer == null) {
+                ConsoleLogger.info("LimboPlayer for '" + player.getName() + "' is not available");
+            } else {
+                cancelTask(limboPlayer.getTimeoutTask());
+                String message = messages.retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR);
+                BukkitTask task = bukkitService.runTaskLater(new TimeoutTask(player, message, playerCache), timeout);
+                limboPlayer.setTimeoutTask(task);
+            }
+        }
+    }
+
+    /**
+     * Null-safe method to cancel a potentially existing task.
+     *
+     * @param task the task to cancel (or null)
+     */
+    private static void cancelTask(BukkitTask task) {
+        if (task != null) {
+            task.cancel();
+        }
+    }
+}

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

@@ -2,53 +2,51 @@ package fr.xephi.authme.task;
 
 import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.cache.limbo.LimboCache;
-import fr.xephi.authme.output.MessageKey;
-import fr.xephi.authme.output.Messages;
 import fr.xephi.authme.util.BukkitService;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
 
+import static fr.xephi.authme.util.BukkitService.TICKS_PER_SECOND;
+
 /**
+ * Message shown to a player in a regular interval as long as he is not logged in.
  */
 public class MessageTask implements Runnable {
 
-    private final BukkitService bukkitService;
     private final String name;
-    private final String[] msg;
+    private final String[] message;
     private final int interval;
+    private final BukkitService bukkitService;
+    private final LimboCache limboCache;
+    private final PlayerCache playerCache;
 
     /*
      * Constructor.
      */
-    public MessageTask(BukkitService bukkitService, String name, String[] lines, int interval) {
-        this.bukkitService = bukkitService;
+    public MessageTask(String name, String[] lines, int interval, BukkitService bukkitService,
+                       LimboCache limboCache, PlayerCache playerCache) {
         this.name = name;
-        this.msg = lines;
+        this.message = lines;
         this.interval = interval;
-    }
-
-    /*
-     * Constructor.
-     */
-    public MessageTask(BukkitService bukkitService, Messages messages, String name, MessageKey messageKey,
-                       int interval) {
-        this(bukkitService, name, messages.retrieve(messageKey), interval);
+        this.bukkitService = bukkitService;
+        this.limboCache = limboCache;
+        this.playerCache = playerCache;
     }
 
     @Override
     public void run() {
-        if (PlayerCache.getInstance().isAuthenticated(name)) {
+        if (playerCache.isAuthenticated(name)) {
             return;
         }
 
         for (Player player : bukkitService.getOnlinePlayers()) {
             if (player.getName().equalsIgnoreCase(name)) {
-                for (String ms : msg) {
+                for (String ms : message) {
                     player.sendMessage(ms);
                 }
-                BukkitTask nextTask = bukkitService.runTaskLater(this, interval * 20);
-                if (LimboCache.getInstance().hasLimboPlayer(name)) {
-                    LimboCache.getInstance().getLimboPlayer(name).setMessageTask(nextTask);
+                BukkitTask nextTask = bukkitService.runTaskLater(this, interval * TICKS_PER_SECOND);
+                if (limboCache.hasLimboPlayer(name)) {
+                    limboCache.getLimboPlayer(name).setMessageTask(nextTask);
                 }
                 return;
             }

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

@@ -1,34 +1,34 @@
 package fr.xephi.authme.task;
 
-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.entity.Player;
 
+/**
+ * Kicks a player if he hasn't logged in (scheduled to run after a configured delay).
+ */
 public class TimeoutTask implements Runnable {
 
-    private final String name;
-    private final Messages m;
     private final Player player;
+    private final String message;
+    private final PlayerCache playerCache;
 
     /**
      * Constructor for TimeoutTask.
      *
-     * @param plugin AuthMe
-     * @param name   String
-     * @param player Player
+     * @param player the player to check
+     * @param message the kick message
+     * @param playerCache player cache instance
      */
-    public TimeoutTask(AuthMe plugin, String name, Player player) {
-        this.m = plugin.getMessages();
-        this.name = name;
+    public TimeoutTask(Player player, String message, PlayerCache playerCache) {
+        this.message = message;
         this.player = player;
+        this.playerCache = playerCache;
     }
 
     @Override
     public void run() {
-        if (!PlayerCache.getInstance().isAuthenticated(name)) {
-            player.kickPlayer(m.retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR));
+        if (!playerCache.isAuthenticated(player.getName())) {
+            player.kickPlayer(message);
         }
     }
 }