fix: improve Folia 1.21.11 compatibility

Author: dike-gay

build.gradle.kts

@@ -50,6 +50,12 @@ tasks.withType<JavaCompile> {
     options.encoding = "UTF-8"
 }
 
+tasks.processResources {
+    filesMatching(listOf("plugin.yml", "paper-plugin.yml")) {
+        expand("version" to project.version)
+    }
+}
+
 tasks.withType<DokkaTask>().configureEach {
     moduleName.set("MatrixLib API")
     dokkaSourceSets.configureEach {

gradle.properties

@@ -1,5 +1,5 @@
 group=com.y54895.matrixlib
-version=1.5.0
+version=1.5.1
 kotlin.incremental=true
 kotlin.incremental.java=true
 kotlin.caching.enabled=true

src/main/kotlin/com/y54895/matrixlib/MatrixLib.kt

@@ -60,6 +60,7 @@ object MatrixLib : Plugin() {
     }
 
     override fun onDisable() {
+        MatrixPluginUpdates.shutdown()
         MatrixConsoleVisuals.renderShutdown(
             branding = branding,
             details = listOf(

src/main/kotlin/com/y54895/matrixlib/api/compat/CompatApi.kt

@@ -15,6 +15,7 @@ import org.bukkit.material.Hopper as LegacyHopper
 import org.bukkit.plugin.Plugin
 import java.lang.reflect.Method
 import java.util.Locale
+import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
 import java.util.function.Consumer
 
@@ -52,6 +53,10 @@ object ServerCompat {
         val implementationClass = server.javaClass.name
         val serverName = runCatching { server.name }.getOrElse { Bukkit.getName() }
         val versionText = Bukkit.getVersion()
+        val hasFoliaSchedulers =
+            serverHasMethod(server, "getGlobalRegionScheduler") &&
+                serverHasMethod(server, "getRegionScheduler") &&
+                serverHasMethod(server, "getAsyncScheduler")
         val composite = listOf(serverName, versionText, implementationClass)
             .joinToString(" ")
             .lowercase(Locale.ROOT)
@@ -61,7 +66,9 @@ object ServerCompat {
         }
 
         when {
-            classExists("io.papermc.paper.threadedregions.RegionizedServer") || composite.contains("folia") -> {
+            classExists("io.papermc.paper.threadedregions.RegionizedServer") ||
+                composite.contains("folia") ||
+                hasFoliaSchedulers -> {
                 ServerRuntime(ServerFamily.FOLIA, "Folia", serverName, versionText, implementationClass)
             }
             classExists("io.papermc.paper.configuration.Configuration") || composite.contains("paper") ||
@@ -120,6 +127,12 @@ object ServerCompat {
             Class.forName(className)
         }.isSuccess
     }
+
+    private fun serverHasMethod(server: Any, name: String): Boolean {
+        return runCatching {
+            server.javaClass.getMethod(name)
+        }.isSuccess
+    }
 }
 
 object BukkitCompat {
@@ -441,11 +454,11 @@ object BukkitCompat {
 object SchedulerBridge {
 
     fun runLater(plugin: Plugin, delayTicks: Long, task: Runnable) {
-        Bukkit.getScheduler().runTaskLater(plugin, task, delayTicks)
+        FoliaUtil.runLater(plugin, delayTicks, task)
     }
 
     fun runAsync(plugin: Plugin, task: Runnable) {
-        Bukkit.getScheduler().runTaskAsynchronously(plugin, task)
+        FoliaUtil.runAsync(plugin, task)
     }
 
     fun runPlayerTaskLater(plugin: Plugin, player: Player, delayTicks: Long, task: Runnable) {
@@ -512,6 +525,22 @@ object FoliaUtil {
         }
     }
 
+    private val asyncScheduler by lazy {
+        if (!isFolia) {
+            null
+        } else {
+            runCatching {
+                Bukkit.getServer().javaClass.getMethod("getAsyncScheduler").invoke(Bukkit.getServer())
+            }.getOrNull()
+        }
+    }
+
+    private val asyncRunNowMethod by lazy {
+        asyncScheduler?.javaClass?.methods?.firstOrNull {
+            it.name == "runNow" && it.parameterCount == 2
+        }
+    }
+
     private val regionScheduler by lazy {
         if (!isFolia) {
             null
@@ -589,6 +618,32 @@ object FoliaUtil {
         return TaskHandle { task.cancel() }
     }
 
+    fun runAsync(plugin: Plugin, action: Runnable): TaskHandle {
+        if (!isFolia) {
+            val task = Bukkit.getScheduler().runTaskAsynchronously(plugin, action)
+            return TaskHandle { task.cancel() }
+        }
+
+        var scheduledTask: Any? = null
+        val consumer = Consumer<Any?> { task ->
+            if (scheduledTask == null && task != null) {
+                scheduledTask = task
+            }
+            action.run()
+        }
+
+        val returnedTask = invokeAsync(asyncRunNowMethod, plugin, consumer)
+        if (returnedTask != null) {
+            scheduledTask = returnedTask
+        }
+        if (scheduledTask != null) {
+            return TaskHandle { cancelScheduledTask(scheduledTask) }
+        }
+
+        val future = CompletableFuture.runAsync(action)
+        return TaskHandle { future.cancel(true) }
+    }
+
     fun runAtLocation(plugin: Plugin, location: Location, action: Runnable) {
         if (!isFolia) {
             action.run()
@@ -653,6 +708,14 @@ object FoliaUtil {
         }.getOrNull()
     }
 
+    private fun invokeAsync(method: Method?, vararg args: Any?): Any? {
+        val scheduler = asyncScheduler ?: return null
+        val targetMethod = method ?: return null
+        return runCatching {
+            targetMethod.invoke(scheduler, *args)
+        }.getOrNull()
+    }
+
     private fun cancelScheduledTask(task: Any?) {
         val scheduledTask = task ?: return
         val cancelMethod = scheduledTaskCancelMethods.computeIfAbsent(scheduledTask.javaClass) { taskClass ->

src/main/kotlin/com/y54895/matrixlib/api/update/MatrixPluginUpdates.kt

@@ -117,7 +117,7 @@ object MatrixPluginUpdates {
     private var bootstrapped = false
 
     @Volatile
-    private var repeatingTaskId = -1
+    private var repeatingTask: FoliaUtil.TaskHandle? = null
 
     lateinit var settings: MatrixUpdateSettings
         private set
@@ -263,6 +263,15 @@ object MatrixPluginUpdates {
         return releaseNotesPreview(candidate.release.body)
     }
 
+    fun shutdown() {
+        repeatingTask?.cancel()
+        repeatingTask = null
+        registrations.clear()
+        candidates.clear()
+        notifiedOps.clear()
+        bootstrapped = false
+    }
+
     private fun checkAsync(managed: MatrixManagedPlugin, sender: CommandSender? = null) {
         if (!settings.enabled) {
             return
@@ -442,21 +451,18 @@ object MatrixPluginUpdates {
         if (settings.checkIntervalMinutes <= 0L) {
             return
         }
-        val periodTicks = settings.checkIntervalMinutes * 60L * 20L
-        repeatingTaskId = FoliaUtil.runRepeating(
+        val periodMinutes = settings.checkIntervalMinutes
+        repeatingTask?.cancel()
+        repeatingTask = FoliaUtil.runRepeating(
             BukkitPlugin.getInstance(),
-            periodTicks,
-            periodTicks,
+            periodMinutes * 60L * 20L,
+            periodMinutes * 60L * 20L,
             Runnable { checkAllAsync() }
-        ).hashCode()
+        )
     }
 
     private fun runAsync(block: () -> Unit) {
-        if (FoliaUtil.isFolia) {
-            FoliaUtil.runLater(BukkitPlugin.getInstance(), 1L, Runnable(block))
-        } else {
-            Bukkit.getScheduler().runTaskAsynchronously(BukkitPlugin.getInstance(), Runnable(block))
-        }
+        FoliaUtil.runAsync(BukkitPlugin.getInstance(), Runnable(block))
     }
 
     private fun loadSettings(): MatrixUpdateSettings {
@@ -549,4 +555,4 @@ private fun CommandSender.sendUpdaterMessage(text: String) {
 
 fun CommandSender.sendMatrixUpdaterMessage(text: String) {
     sendUpdaterMessage(text)
-}
+}