first commit

source/decompiled/de/maxhenkel/voicechat/compatibility/BaseCompatibility.java

@@ -0,0 +1,211 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.annotation.Nullable
+ *  org.bukkit.Bukkit
+ *  org.bukkit.entity.Player
+ *  org.bukkit.event.EventPriority
+ *  org.bukkit.event.Listener
+ *  org.bukkit.event.player.PlayerEvent
+ *  org.bukkit.plugin.Plugin
+ */
+package de.maxhenkel.voicechat.compatibility;
+
+import de.maxhenkel.voicechat.Voicechat;
+import de.maxhenkel.voicechat.compatibility.Compatibility;
+import de.maxhenkel.voicechat.compatibility.CompatibilityReflectionException;
+import de.maxhenkel.voicechat.compatibility.PlayerHideEvent;
+import de.maxhenkel.voicechat.compatibility.PlayerShowEvent;
+import de.maxhenkel.voicechat.compatibility.ReflectionUtils;
+import de.maxhenkel.voicechat.util.Key;
+import java.lang.reflect.Method;
+import java.util.function.Consumer;
+import javax.annotation.Nullable;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerEvent;
+import org.bukkit.plugin.Plugin;
+
+public abstract class BaseCompatibility
+implements Compatibility {
+    private String baseBukkitPackage;
+    private String baseServerPackage;
+    private Method addChannel;
+    private Method removeChannel;
+    @Nullable
+    private Class<? extends PlayerEvent> playerHideEntityEvent;
+    @Nullable
+    private Method playerHideEntityEventGetEntity;
+    @Nullable
+    private Class<? extends PlayerEvent> playerShowEntityEvent;
+    @Nullable
+    private Method playerShowEntityEventGetEntity;
+    private Consumer<Runnable> runTask;
+    private TaskScheduler taskScheduler;
+
+    @Override
+    public void init() throws Exception {
+        Compatibility.super.init();
+        this.baseBukkitPackage = Bukkit.getServer().getClass().getPackage().getName();
+        this.baseServerPackage = ReflectionUtils.callMethod((Object)Bukkit.getServer(), "getServer").getClass().getPackage().getName();
+        Class<?> craftPlayer = this.getBukkitClass("entity.CraftPlayer");
+        this.addChannel = ReflectionUtils.getMethod(craftPlayer, new String[]{"addChannel"}, new Class[]{String.class});
+        this.removeChannel = ReflectionUtils.getMethod(craftPlayer, new String[]{"removeChannel"}, new Class[]{String.class});
+        try {
+            if (ReflectionUtils.doesClassExist("org.bukkit.event.player.PlayerHideEntityEvent") && ReflectionUtils.doesClassExist("org.bukkit.event.player.PlayerShowEntityEvent")) {
+                Class<?> hide = ReflectionUtils.getClazz("org.bukkit.event.player.PlayerHideEntityEvent");
+                if (!PlayerEvent.class.isAssignableFrom(hide)) {
+                    throw new CompatibilityReflectionException("PlayerHideEntityEvent is not a subclass of PlayerEvent");
+                }
+                Class<?> show = ReflectionUtils.getClazz("org.bukkit.event.player.PlayerShowEntityEvent");
+                if (!PlayerEvent.class.isAssignableFrom(show)) {
+                    throw new CompatibilityReflectionException("PlayerShowEntityEvent is not a subclass of PlayerEvent");
+                }
+                this.playerShowEntityEventGetEntity = ReflectionUtils.getMethod(show, "getEntity");
+                this.playerHideEntityEventGetEntity = ReflectionUtils.getMethod(hide, "getEntity");
+                this.playerShowEntityEvent = show;
+                this.playerHideEntityEvent = hide;
+            } else {
+                Voicechat.LOGGER.warn("Vanish plugin integration is not supported", new Object[0]);
+            }
+        }
+        catch (CompatibilityReflectionException e) {
+            Voicechat.LOGGER.warn("Vanish plugin integration is disabled", new Object[0]);
+            Voicechat.LOGGER.warn("Failed to load vanish compatibility", e);
+            this.playerHideEntityEvent = null;
+            this.playerShowEntityEvent = null;
+        }
+        this.runTask = runnable -> Bukkit.getScheduler().runTask((Plugin)Voicechat.INSTANCE, runnable);
+        this.taskScheduler = new TaskScheduler(){
+
+            @Override
+            public void scheduleSyncRepeatingTask(Runnable runnable, long delay, long period) {
+                Bukkit.getScheduler().scheduleSyncRepeatingTask((Plugin)Voicechat.INSTANCE, runnable, delay, period);
+            }
+
+            @Override
+            public void runTaskLater(Runnable runnable, long delay) {
+                Bukkit.getScheduler().runTaskLater((Plugin)Voicechat.INSTANCE, runnable, delay);
+            }
+        };
+        if (ReflectionUtils.doesMethodExist(Bukkit.class, "getGlobalRegionScheduler", new Class[0])) {
+            final Object globalRegionScheduler = ReflectionUtils.callMethod(Bukkit.class, "getGlobalRegionScheduler");
+            Method run = ReflectionUtils.getMethod(globalRegionScheduler.getClass(), new String[]{"run"}, new Class[]{Plugin.class, Consumer.class});
+            this.runTask = runnable -> ReflectionUtils.call(run, globalRegionScheduler, new Object[]{Voicechat.INSTANCE, task -> runnable.run()});
+            if (ReflectionUtils.doesMethodExist(globalRegionScheduler.getClass(), "runAtFixedRate", Plugin.class, Consumer.class, Long.TYPE, Long.TYPE) && ReflectionUtils.doesMethodExist(globalRegionScheduler.getClass(), "runDelayed", Plugin.class, Consumer.class, Long.TYPE)) {
+                final Method runAtFixedRate = ReflectionUtils.getMethod(globalRegionScheduler.getClass(), new String[]{"runAtFixedRate"}, new Class[]{Plugin.class, Consumer.class, Long.TYPE, Long.TYPE});
+                final Method runDelayed = ReflectionUtils.getMethod(globalRegionScheduler.getClass(), new String[]{"runDelayed"}, new Class[]{Plugin.class, Consumer.class, Long.TYPE});
+                this.taskScheduler = new TaskScheduler(){
+                    final /* synthetic */ BaseCompatibility this$0;
+                    {
+                        this.this$0 = this$0;
+                    }
+
+                    @Override
+                    public void scheduleSyncRepeatingTask(Runnable runnable, long delay, long period) {
+                        ReflectionUtils.call(runAtFixedRate, globalRegionScheduler, new Object[]{Voicechat.INSTANCE, task -> runnable.run(), delay <= 0L ? 1L : delay, period});
+                    }
+
+                    @Override
+                    public void runTaskLater(Runnable runnable, long delay) {
+                        ReflectionUtils.call(runDelayed, globalRegionScheduler, new Object[]{Voicechat.INSTANCE, task -> runnable.run(), delay <= 0L ? 1L : delay});
+                    }
+                };
+            }
+        }
+    }
+
+    @Override
+    public void addChannel(Player player, String channel) {
+        ReflectionUtils.call(this.addChannel, player, channel);
+    }
+
+    @Override
+    public void removeChannel(Player player, String channel) {
+        ReflectionUtils.call(this.removeChannel, player, channel);
+    }
+
+    @Override
+    public Key createNamespacedKey(String key) {
+        return Key.of(key);
+    }
+
+    @Override
+    public void runTask(Runnable runnable) {
+        this.runTask.accept(runnable);
+    }
+
+    @Override
+    public void scheduleSyncRepeatingTask(Runnable runnable, long delay, long period) {
+        this.taskScheduler.scheduleSyncRepeatingTask(runnable, delay, period);
+    }
+
+    @Override
+    public void runTaskLater(Runnable runnable, long delay) {
+        this.taskScheduler.runTaskLater(runnable, delay);
+    }
+
+    @Override
+    public boolean canSee(Player player, Player other) {
+        if (this.playerHideEntityEvent == null || this.playerShowEntityEvent == null) {
+            return true;
+        }
+        return player.canSee(other);
+    }
+
+    @Override
+    public void registerPlayerHideEvent(Consumer<PlayerHideEvent> event) {
+        if (this.playerHideEntityEvent == null) {
+            return;
+        }
+        Bukkit.getPluginManager().registerEvent(this.playerHideEntityEvent, new Listener(){}, EventPriority.NORMAL, (listener, evt) -> {
+            if (!evt.getClass().isAssignableFrom(this.playerHideEntityEvent)) {
+                return;
+            }
+            PlayerEvent playerEvent = (PlayerEvent)evt;
+            Object entityObj = ReflectionUtils.call(this.playerHideEntityEventGetEntity, playerEvent, new Object[0]);
+            if (!(entityObj instanceof Player)) {
+                return;
+            }
+            event.accept(new PlayerHideEvent((Player)entityObj, playerEvent.getPlayer()));
+        }, (Plugin)Voicechat.INSTANCE);
+    }
+
+    @Override
+    public void registerPlayerShowEvent(Consumer<PlayerShowEvent> event) {
+        if (this.playerShowEntityEvent == null) {
+            return;
+        }
+        Bukkit.getPluginManager().registerEvent(this.playerShowEntityEvent, new Listener(){}, EventPriority.NORMAL, (listener, evt) -> {
+            if (!evt.getClass().isAssignableFrom(this.playerShowEntityEvent)) {
+                return;
+            }
+            PlayerEvent playerEvent = (PlayerEvent)evt;
+            Object entityObj = ReflectionUtils.call(this.playerShowEntityEventGetEntity, playerEvent, new Object[0]);
+            if (!(entityObj instanceof Player)) {
+                return;
+            }
+            event.accept(new PlayerShowEvent((Player)entityObj, playerEvent.getPlayer()));
+        }, (Plugin)Voicechat.INSTANCE);
+    }
+
+    @Override
+    public String getBaseBukkitPackage() {
+        return this.baseBukkitPackage;
+    }
+
+    @Override
+    public String getBaseServerPackage() {
+        return this.baseServerPackage;
+    }
+
+    private static interface TaskScheduler {
+        public void scheduleSyncRepeatingTask(Runnable var1, long var2, long var4);
+
+        public void runTaskLater(Runnable var1, long var2);
+    }
+}
+