Example usage for com.google.common.io ByteArrayDataOutput writeInt

List of usage examples for com.google.common.io ByteArrayDataOutput writeInt

Introduction

In this page you can find the example usage for com.google.common.io ByteArrayDataOutput writeInt.

Prototype

@Override
    void writeInt(int v);

Source Link

Usage

From source file:codecrafter47.bungeetablistplus.bukkitbridge.BukkitBridge.java

public void onEnable() {
    try {/*from  ww w  . j  av  a 2 s . com*/
        Field field = BungeeTabListPlusBukkitAPI.class.getDeclaredField("instance");
        field.setAccessible(true);
        field.set(null, this);
    } catch (NoSuchFieldException | IllegalAccessException ex) {
        plugin.getLogger().log(Level.SEVERE, "Failed to initialize API", ex);
    }

    plugin.getServer().getMessenger().registerOutgoingPluginChannel(plugin, BridgeProtocolConstants.CHANNEL);
    plugin.getServer().getMessenger().registerIncomingPluginChannel(plugin, BridgeProtocolConstants.CHANNEL,
            (string, player, bytes) -> {

                DataInput input = new DataInputStream(new ByteArrayInputStream(bytes));

                try {
                    int messageId = input.readUnsignedByte();

                    switch (messageId) {
                    case BridgeProtocolConstants.MESSAGE_ID_PROXY_HANDSHAKE:
                        UUID proxyId = DataStreamUtils.readUUID(input);
                        int protocolVersion = input.readInt();

                        if (protocolVersion > BridgeProtocolConstants.VERSION) {
                            rlExecutor.execute(() -> plugin.getLogger()
                                    .warning("BungeeTabListPlus_BukkitBridge is outdated."));
                        } else if (protocolVersion < BridgeProtocolConstants.VERSION) {
                            rlExecutor.execute(() -> plugin.getLogger()
                                    .warning("BungeeTabListPlus proxy plugin outdated."));
                        } else {
                            playerData.put(player, new PlayerBridgeData(proxyId));
                            serverData.computeIfAbsent(proxyId, uuid -> new ServerBridgeData());
                            ByteArrayDataOutput data = ByteStreams.newDataOutput();
                            data.writeByte(BridgeProtocolConstants.MESSAGE_ID_SERVER_HANDSHAKE);
                            player.sendPluginMessage(plugin, BridgeProtocolConstants.CHANNEL,
                                    data.toByteArray());
                        }

                        break;

                    case BridgeProtocolConstants.MESSAGE_ID_PROXY_REQUEST_DATA:
                        BridgeData bridgeData = playerData.get(player);
                        if (bridgeData != null) {
                            handleDataRequest(bridgeData, input);
                        }
                        break;

                    case BridgeProtocolConstants.MESSAGE_ID_PROXY_REQUEST_SERVER_DATA:
                        PlayerBridgeData playerBridgeData = playerData.get(player);
                        if (playerBridgeData != null) {
                            bridgeData = serverData.get(playerBridgeData.proxyId);
                            if (bridgeData != null) {
                                handleDataRequest(bridgeData, input);
                            }
                        }
                        break;

                    case BridgeProtocolConstants.MESSAGE_ID_PROXY_OUTDATED:
                        rlExecutor.execute(
                                () -> plugin.getLogger().warning("BungeeTabListPlus proxy plugin outdated."));
                        break;

                    case BridgeProtocolConstants.MESSAGE_ID_PROXY_REQUEST_RESET_SERVER_DATA:
                        playerBridgeData = playerData.get(player);
                        if (playerBridgeData != null) {
                            bridgeData = serverData.get(playerBridgeData.proxyId);
                            if (bridgeData != null) {
                                serverData.put(playerBridgeData.proxyId, new ServerBridgeData());
                            }
                        }
                        break;

                    default:
                        plugin.getLogger().warning("Received unknown message id " + messageId);
                        break;
                    }
                } catch (IOException ex) {
                    plugin.getLogger().log(Level.SEVERE,
                            "An unexpected error occurred while processing a plugin message.", ex);
                }
            });

    plugin.getServer().getPluginManager().registerEvents(this, plugin);

    updateDataHooks();

    // initialize bridge for players already on the server
    for (Player player : plugin.getServer().getOnlinePlayers()) {
        ByteArrayDataOutput data = ByteStreams.newDataOutput();
        data.writeByte(BridgeProtocolConstants.MESSAGE_ID_SERVER_ENABLE_CONNECTION);
        try {
            DataStreamUtils.writeUUID(data, serverId);
        } catch (IOException e) {
            throw new AssertionError(e);
        }
        player.sendPluginMessage(plugin, BridgeProtocolConstants.CHANNEL, data.toByteArray());
    }

    // start update task
    plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, () -> {
        long now = System.currentTimeMillis();
        Map<UUID, Player> proxyIds = new HashMap<>();

        for (Map.Entry<Player, PlayerBridgeData> e : playerData.entrySet()) {
            Player player = e.getKey();
            PlayerBridgeData bridgeData = e.getValue();

            proxyIds.putIfAbsent(bridgeData.proxyId, player);

            int size = 0;

            for (CacheEntry entry : bridgeData.requestedData) {
                Object value = playerDataAccess.get(entry.key, player);
                entry.dirty = !Objects.equals(value, entry.value);
                entry.value = value;

                if (entry.dirty) {
                    size++;
                }
            }

            if (size != 0) {
                ByteArrayDataOutput data = ByteStreams.newDataOutput();
                data.writeByte(BridgeProtocolConstants.MESSAGE_ID_SERVER_UPDATE_DATA);
                data.writeInt(size);

                for (CacheEntry entry : bridgeData.requestedData) {
                    if (entry.dirty) {
                        data.writeInt(entry.netId);
                        data.writeBoolean(entry.value == null);
                        if (entry.value != null) {
                            try {
                                typeRegistry.getTypeAdapter((TypeToken<Object>) entry.key.getType()).write(data,
                                        entry.value);
                            } catch (java.io.IOException e1) {
                                e1.printStackTrace();
                            }
                        }
                    }
                }

                player.sendPluginMessage(plugin, BridgeProtocolConstants.CHANNEL, data.toByteArray());
            }
        }

        for (Map.Entry<UUID, Player> e : proxyIds.entrySet()) {
            UUID proxyId = e.getKey();
            Player player = e.getValue();
            ServerBridgeData bridgeData = serverData.get(proxyId);

            if (bridgeData == null) {
                continue;
            }

            bridgeData.lastUpdate = now;

            int size = 0;

            for (CacheEntry entry : bridgeData.requestedData) {
                Object value = serverDataAccess.get(entry.key, plugin.getServer());
                entry.dirty = !Objects.equals(value, entry.value);
                entry.value = value;

                if (entry.dirty) {
                    size++;
                }
            }

            ByteArrayDataOutput data = ByteStreams.newDataOutput();
            data.writeByte(BridgeProtocolConstants.MESSAGE_ID_SERVER_UPDATE_SERVER_DATA);

            if (size > 0) {
                bridgeData.revision++;
            }

            data.writeInt(bridgeData.revision);
            data.writeInt(size);

            for (CacheEntry entry : bridgeData.requestedData) {
                if (entry.dirty) {
                    data.writeInt(entry.netId);
                    data.writeBoolean(entry.value == null);
                    if (entry.value != null) {
                        try {
                            typeRegistry.getTypeAdapter((TypeToken<Object>) entry.key.getType()).write(data,
                                    entry.value);
                        } catch (java.io.IOException e1) {
                            e1.printStackTrace();
                        }
                    }
                }
            }

            player.sendPluginMessage(plugin, BridgeProtocolConstants.CHANNEL, data.toByteArray());
        }

        for (Iterator<ServerBridgeData> iterator = serverData.values().iterator(); iterator.hasNext();) {
            ServerBridgeData data = iterator.next();
            if (now - data.lastUpdate > 900000) {
                iterator.remove();
            }
        }

    }, 20, 20);
}