@EventHandler
public void handle(PlayerKickEvent e) {
    Player player = e.getPlayer();
    if (handled.get(player.getUniqueId()) != Lifecycle.DATA_SENT) {
        return;
    }

    DataSupply supply = new DataSupply();// So we magic send player data at kick event.
    supply.setId(player.getUniqueId());
    supply.setGroup(group);
    if (isLocked(player.getUniqueId())) {
        supply.setBuf(EMPTY_ARRAY);
    } else {
        manager.lockUser(player);
        PlayerData dat = manager.getUserData(player, true);
        pending.put(player.getUniqueId(), dat);
        supply.setBuf(PlayerDataHelper.encode(dat));
    }

    byte[] message = supply.encode();
    if (message.length > Messenger.MAX_MESSAGE_SIZE) {// Overflow?
        supply.setBuf(EMPTY_ARRAY);
        message = supply.encode();
    }

    player.sendPluginMessage(main, PlayerSqlProtocol.NAMESPACE, message);// BungeeCord received this before kicks
}
 

@Override
public void register() {
    Messenger messenger = Bukkit.getMessenger();
    messenger.registerOutgoingPluginChannel(plugin, BUNGEE_CHANNEL);
    messenger.registerIncomingPluginChannel(plugin, BUNGEE_CHANNEL, this);

    Bukkit.getScheduler().runTaskTimer(plugin, this, UPDATE_INTERVAL, UPDATE_INTERVAL);

    register("bungee-online").scoreSupply(() -> onlinePlayers);
}
 

@Override
public void reload(final Settings settings) {
    this.isEnabled = settings.getProperty(HooksSettings.BUNGEECORD);
    this.destinationServerOnLogin = settings.getProperty(HooksSettings.BUNGEECORD_SERVER);

    if (this.isEnabled) {
        final Messenger messenger = plugin.getServer().getMessenger();
        if (!messenger.isOutgoingChannelRegistered(plugin, "BungeeCord")) {
            messenger.registerOutgoingPluginChannel(plugin, "BungeeCord");
        }
    }
}
 

@Override
public void reload(final Settings settings) {
    this.isEnabled = settings.getProperty(HooksSettings.BUNGEECORD);

    if (this.isEnabled) {
        final Messenger messenger = plugin.getServer().getMessenger();
        if (!messenger.isIncomingChannelRegistered(plugin, "BungeeCord")) {
            messenger.registerIncomingPluginChannel(plugin, "BungeeCord", this);
        }
    }
}
 

@Override
public Messenger getMessenger() {
    return messenger;
}
 

@Inject PlayerServerChanger(Plugin plugin, Messenger messenger, Server localServer) {
    this.plugin = plugin;
    this.messenger = messenger;
    this.localServer = localServer;
}
 

/**
 * Sends a plugin message.
 *
 * Example usage using the "GetServers" bungee plugin message channel via an overload:
 * <code>
 *     Utils.sendPluginMessage("BungeeCord", r -> "GetServers".equals(r.readUTF()), "GetServers")
 *     			.thenAccept(response -> Bukkit.broadcastMessage(response.readUTF()) // comma delimited server broadcast
 *     			.exceptionally(ex -> {
 *     			 	Skript.warning("Failed to get servers because there are no players online");
 *     			 	return null;
 *     			});
 * </code>
 *
 * @param player the player to send the plugin message through
 * @param channel the channel for this plugin message
 * @param messageVerifier verifies that a plugin message is the response to the sent message
 * @param data the data to add to the outgoing message
 * @return a completable future for the message of the responding plugin message, if there is one.
 * this completable future will complete exceptionally if the player is null.
 */
public static CompletableFuture<ByteArrayDataInput> sendPluginMessage(Player player, String channel,
		Predicate<ByteArrayDataInput> messageVerifier, String... data) {
	CompletableFuture<ByteArrayDataInput> completableFuture = new CompletableFuture<>();

	if (player == null) {
		completableFuture.completeExceptionally(new IllegalStateException("Can't send plugin messages from a null player"));
		return completableFuture;
	}

	Skript skript = Skript.getInstance();
	Messenger messenger = Bukkit.getMessenger();

	messenger.registerOutgoingPluginChannel(skript, channel);

	PluginMessageListener listener = (sendingChannel, sendingPlayer, message) -> {
		ByteArrayDataInput input = ByteStreams.newDataInput(message);
		if (channel.equals(sendingChannel) && sendingPlayer == player && !completableFuture.isDone()
				&& !completableFuture.isCancelled() && messageVerifier.test(input)) {
			completableFuture.complete(input);
		}
	};

	messenger.registerIncomingPluginChannel(skript, channel, listener);

	completableFuture.whenComplete((r, ex) -> messenger.unregisterIncomingPluginChannel(skript, channel, listener));

	// if we haven't gotten a response after a minute, let's just assume there wil never be one
	Bukkit.getScheduler().scheduleSyncDelayedTask(skript, () -> {

		if (!completableFuture.isDone())
			completableFuture.cancel(true);

	}, 60 * 20);

	ByteArrayDataOutput out = ByteStreams.newDataOutput();
	Stream.of(data).forEach(out::writeUTF);
	player.sendPluginMessage(Skript.getInstance(), channel, out.toByteArray());

	return completableFuture;
}
 

@Override
public Messenger getMessenger() {
    throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
 

@Override
public Messenger getMessenger() {
    return null;
}
 

@Override
public Messenger getMessenger() {
    return messenger;
}
 

/**
 * Gets the {@link Messenger} responsible for this server.
 *
 * @return messenger responsible for this server
 */
public Messenger getMessenger();
 

/**
 * Gets the {@link Messenger} responsible for this server.
 *
 * @return messenger responsible for this server
 */
public static Messenger getMessenger() {
    return server.getMessenger();
}