com.velocitypowered.api.plugin.PluginContainer Java Examples

@Override
public PluginContainer createPlugin(PluginDescription description) throws Exception {
  if (!(description instanceof JavaVelocityPluginDescription)) {
    throw new IllegalArgumentException("Description provided isn't of the Java plugin loader");
  }

  JavaVelocityPluginDescription javaDescription = (JavaVelocityPluginDescription) description;
  Optional<Path> source = javaDescription.getSource();

  if (!source.isPresent()) {
    throw new IllegalArgumentException("No path in plugin description");
  }

  Injector injector = Guice
      .createInjector(new VelocityPluginModule(server, javaDescription, baseDirectory));
  Object instance = injector.getInstance(javaDescription.getMainClass());

  if (instance == null) {
    throw new IllegalStateException(
        "Got nothing from injector for plugin " + javaDescription.getId());
  }

  return new VelocityPluginContainer(description, instance);
}
 

private List<QueryResponse.PluginInformation> getRealPluginInformation() {
  // Effective Java, Third Edition; Item 83: Use lazy initialization judiciously
  List<QueryResponse.PluginInformation> res = pluginInformationList;
  if (res == null) {
    synchronized (this) {
      if (pluginInformationList == null) {
        pluginInformationList = res = server.getPluginManager().getPlugins().stream()
            .map(PluginContainer::getDescription)
            .map(desc -> QueryResponse.PluginInformation
                .of(desc.getName().orElse(desc.getId()), desc.getVersion().orElse(null)))
            .collect(Collectors.toList());
      }
    }
  }
  return res;
}
 

@Override
public void execute(CommandSource source, String @NonNull [] args) {
  if (args.length != 0) {
    source.sendMessage(TextComponent.of("/velocity plugins", TextColor.RED));
    return;
  }

  List<PluginContainer> plugins = ImmutableList.copyOf(server.getPluginManager().getPlugins());
  int pluginCount = plugins.size();

  if (pluginCount == 0) {
    source.sendMessage(TextComponent.of("No plugins installed.", TextColor.YELLOW));
    return;
  }

  TextComponent.Builder output = TextComponent.builder("Plugins: ")
      .color(TextColor.YELLOW);
  for (int i = 0; i < pluginCount; i++) {
    PluginContainer plugin = plugins.get(i);
    output.append(componentForPlugin(plugin.getDescription()));
    if (i + 1 < pluginCount) {
      output.append(TextComponent.of(", "));
    }
  }

  source.sendMessage(output.build());
}
 

@Override
public void load() {
    Object plugin = VelocityPlugin.PROXY.getPluginManager()
            .getPlugin("viaversion").flatMap(PluginContainer::getInstance).get();

    if (ProtocolRegistry.SERVER_PROTOCOL < ProtocolVersion.v1_9.getId()) {
        Via.getManager().getProviders().use(MovementTransmitterProvider.class, new VelocityMovementTransmitter());
        Via.getManager().getProviders().use(BossBarProvider.class, new VelocityBossBarProvider());
        VelocityPlugin.PROXY.getEventManager().register(plugin, new ElytraPatch());
    }

    Via.getManager().getProviders().use(VersionProvider.class, new VelocityVersionProvider());
    // We probably don't need a EntityIdProvider because velocity sends a Join packet on server change
    // We don't need main hand patch because Join Game packet makes client send hand data again

    VelocityPlugin.PROXY.getEventManager().register(plugin, new UpdateListener());
    VelocityPlugin.PROXY.getEventManager().register(plugin, new VelocityServerHandler());

    int pingInterval = ((VelocityViaConfig) Via.getPlatform().getConf()).getVelocityPingInterval();
    if (pingInterval > 0) {
        Via.getPlatform().runRepeatingSync(
                new ProtocolDetectorService(),
                pingInterval * 20L);
    }
}
 

@Override
public JsonObject getDump() {
    JsonObject extra = new JsonObject();
    List<PluginInfo> plugins = new ArrayList<>();
    for (PluginContainer p : PROXY.getPluginManager().getPlugins()) {
        plugins.add(new PluginInfo(
                true,
                p.getDescription().getName().orElse(p.getDescription().getId()),
                p.getDescription().getVersion().orElse("Unknown Version"),
                p.getInstance().isPresent() ? p.getInstance().get().getClass().getCanonicalName() : "Unknown",
                p.getDescription().getAuthors()
        ));
    }
    extra.add("plugins", GsonUtil.getGson().toJsonTree(plugins));
    extra.add("servers", GsonUtil.getGson().toJsonTree(ProtocolDetectorService.getDetectedIds()));
    return extra;
}
 

@Override
public Optional<PluginContainer> fromInstance(Object instance) {
  checkNotNull(instance, "instance");

  if (instance instanceof PluginContainer) {
    return Optional.of((PluginContainer) instance);
  }

  return Optional.ofNullable(pluginInstances.get(instance));
}
 

@Override
public @NonNull Optional<PluginContainer> fromInstance(@NonNull Object instance) {
  if (instance == PLUGIN_A) {
    return Optional.of(PC_A);
  } else if (instance == PLUGIN_B) {
    return Optional.of(PC_B);
  } else {
    return Optional.empty();
  }
}
 

@Override
public @NonNull Optional<PluginContainer> getPlugin(@NonNull String id) {
  switch (id) {
    case "a":
      return Optional.of(PC_A);
    case "b":
      return Optional.of(PC_B);
    default:
      return Optional.empty();
  }
}
 

@Override
protected PluginContainer checkPlugin(Object plugin) throws IllegalArgumentException {
    if (plugin instanceof PluginContainer) {
        return (PluginContainer) plugin;
    }

    PluginContainer pluginContainer = this.plugin.getBootstrap().getProxy().getPluginManager().fromInstance(plugin).orElse(null);
    if (pluginContainer != null) {
        return pluginContainer;
    }

    throw new IllegalArgumentException("Object " + plugin + " (" + plugin.getClass().getName() + ") is not a plugin.");
}
 

public void loadFloodgate(GeyserVelocityPlugin plugin, ProxyServer proxyServer, File dataFolder) {
    Optional<PluginContainer> floodgate = proxyServer.getPluginManager().getPlugin("floodgate");
    floodgate.ifPresent(it -> floodgateKey = FloodgateKeyLoader.getKey(plugin.getGeyserLogger(), this, Paths.get(dataFolder.toString(), floodgateKeyFile.isEmpty() ? floodgateKeyFile : "public-key.pem"), it, Paths.get("plugins/floodgate/")));
}
 

private void registerPlugin(PluginContainer plugin) {
  plugins.put(plugin.getDescription().getId(), plugin);
  Optional<?> instance = plugin.getInstance();
  instance.ifPresent(o -> pluginInstances.put(o, plugin));
}
 

@Override
public Optional<PluginContainer> getPlugin(String id) {
  checkNotNull(id, "id");
  return Optional.ofNullable(plugins.get(id));
}
 

@Override
public Collection<PluginContainer> getPlugins() {
  return Collections.unmodifiableCollection(plugins.values());
}
 

@Override
public @NonNull Collection<PluginContainer> getPlugins() {
  return ImmutableList.of(PC_A, PC_B);
}
 

public String getVersion() {
    Optional<PluginContainer> plugin = this.getProxy().getPluginManager().getPlugin("skinsrestorer");

    if (!plugin.isPresent())
        return "";

    Optional<String> version = plugin.get().getDescription().getVersion();

    return version.orElse("");
}
 

PluginContainer createPlugin(PluginDescription plugin) throws Exception;