Java 类com.esotericsoftware.kryonet.Listener 实例源码

public LoginScreen(CatanGame pGame) {
    aGame = pGame;
    listener = new Listener() {
        @Override
        public void received(Connection connection, Object object) {
            if (object instanceof LoginResponse) {
                Gdx.app.postRunnable(() -> {
                    // Handle the login response from the server
                    if (((LoginResponse) object).success) {
                        // Cache the account used to login successfully
                        AccountManager.writeLocalAccount(account);
                        CatanGame.account = account;
                        // Move on to the main screen
                        aGame.switchScreen(ScreenKind.MAIN_MENU);
                    } else {
                        errorMessageLabel.setText(ERROR_USERNAME);
                    }
                });
            }
        }
    };
}

@Override
public void show() {
    super.show();

    entities = new HashMap<Integer, EntityPacket.EntityRender>();

    game.getClient().sendTCP(new ViewShare("696969"));

    game.getClient().addListener(new Listener() {
        @Override
        public void received(Connection connection, Object o) {
            if(o instanceof EntityPacket)
                Gdx.app.log("Entities", "Session" + ((EntityPacket) o).session);
        }
    });
}

/**
 * Makes this chat client process and respond to audio sent from the server. If this message is not called, you will not hear anything
 * from the server!
 * @param client The client that audio data will be sent to from the server. Just use the normal client.
 */
public void addReceiver(Client client){

    if(this.player == null)
        this.createPlayer();

    client.addListener(new Listener(){
        public void received(Connection connection, Object object) {

            // Only read objects of the correct type.
            if(object instanceof VoiceNetData){

                // Read data
                VoiceNetData message = (VoiceNetData)object;                    
                short[] data = message.getData();

                // Play audio
                processAudio(data, connection, message);
            }
        }           
    });
}

public ClientController(AbstractDiagramController pDiagramController, String pServerIp, int pPort) {
    diagramController = pDiagramController;
    serverIp = pServerIp;
    port = pPort;

    client = new Client();

    initKryo(client.getKryo());

    client.addListener(new Listener() {
        public void received (Connection connection, Object object) {
            if (object instanceof AbstractNode) {
                Platform.runLater(() -> diagramController.createNodeView((AbstractNode)object, true));
            } else if (object instanceof AbstractEdge) {
                Platform.runLater(() -> diagramController.addEdgeView((AbstractEdge)object, true));
            } else if (object instanceof Graph){
                Graph graph = (Graph) object;
                graph.addRemotePropertyChangeListener(ClientController.this);
                Platform.runLater(() -> diagramController.load(graph, true));
            } else if (object instanceof String[]){
                Platform.runLater(() -> diagramController.remoteCommand((String[])object));
            }
        }
    });
}

public boolean connect(NetworkServerConfig config) {
    try {
        this.client.connect(5000, config.getAddress(), config.getTcpPort(), config.getUdpPort());
        this.client.addListener(new Listener() {
            public void received(Connection connection, Object object) {
                if (object instanceof MessageModel) {
                    MessageModel response = (MessageModel) object;
                    masterTask.sendTask(TaskFactory.createTask(EnumTargetTask.MESSAGE_SERVER, EnumTargetTask.GAME, response));
                }
            }
        });
        this.masterTask.sendTask(TaskFactory.createTask(EnumTargetTask.MESSAGE_SERVER, EnumTargetTask.ACCOUNT, EnumWindow.INTERFACE));
        return true;
    } catch (IOException e) {
        System.err.println("ERROR: " + e.getMessage());
        e.printStackTrace();
        return false;
    }
}

public NetworkServerImpl(final NetworkConfigurationData configuration) {
  Validate.notNull(configuration);
  this.configuration = configuration;
  ObjectSpace _objectSpace = new ObjectSpace();
  this.objectSpace = _objectSpace;
  MyServer _myServer = new MyServer(this.objectSpace);
  this.server = _myServer;
  Kryo _kryo = this.server.getKryo();
  ObjectSpace.registerClasses(_kryo);
  Kryo _kryo_1 = this.server.getKryo();
  SerializerHelper.initializeKryo(_kryo_1);
  this.sentBytes = 0L;
  long _currentTimeMillis = System.currentTimeMillis();
  this.lastLog = _currentTimeMillis;
  MyHashMap<Integer, NetworkService> _myHashMap = new MyHashMap<Integer, NetworkService>();
  this.serviceMap = _myHashMap;
  HashSet<Listener> _newHashSet = CollectionLiterals.<Listener>newHashSet();
  this.listeners = _newHashSet;
}

public void getEventsForPeriod(LocalDate from, LocalDate to, ObservableList<Event> observableEvents) {
    EventMessage eventMessage = new EventMessage(currentUser.getValue(), EventMessage.Command.SEND_EVENTS, from, to);
    CalendarClient client = CalendarClient.getInstance();

    Listener listener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof EventMessage) {
                EventMessage message = (EventMessage) object;
                if (message.getCommand() == EventMessage.Command.RECEIVE_EVENTS) {
                    observableEvents.addAll(message.getEvents());
                    client.removeListener(this);
                }
            }
        }
    };

    client.addListener(listener);
    client.sendMessage(eventMessage);
}

private void getAllTeams() {
    TeamMessage message = new TeamMessage(TeamMessage.Command.SEND_TEAMS);
    CalendarClient client = CalendarClient.getInstance();

    Listener getTeamsListener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof TeamMessage) {
                TeamMessage complete = (TeamMessage) object;
                switch (complete.getCommand()) {
                    case RECEIVE_TEAMS:
                        setAllTeams(complete.getTeams());
                        break;
                    case SEND_TEAMS:
                        break;
                }
                client.removeListener(this);
            }
        }

    };
    client.addListener(getTeamsListener);
    client.sendMessage(message);
}

private void getInvited(int id) {
    RequestMessage message = new RequestMessage(RequestMessage.Command.INVITED_USERS_REQUEST, id);

    CalendarClient client = CalendarClient.getInstance();

    Listener getInvitedListener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof ParticipantUserMessage) {
                ParticipantUserMessage complete = (ParticipantUserMessage) object;
                switch (complete.getCommand()) {
                    case RECEIVE_ALL:
                        setInvited(complete.getParticipantUsers());
                        break;
                    case SEND_ALL:
                        break;
                }
                client.removeListener(this);
            }
        }
    };
    client.addListener(getInvitedListener);
    client.sendMessage(message);
}

public void findUsers() {
    UserMessage userMessage = new UserMessage(UserMessage.Command.SEND_ALL);
    CalendarClient client = CalendarClient.getInstance();

    Listener listener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof UserMessage) {
                UserMessage message = (UserMessage) object;
                if (message.getCommand() == UserMessage.Command.RECEIVE_ALL) {
                    users.addAll(message.getUsers());
                    allUsers.addAll(message.getUsers());
                    client.removeListener(this);
                }
            }
        }
    };

    client.addListener(listener);
    client.sendMessage(userMessage);
}

private void listenForNotifications() {
    NotificationMessage findNotifications = new NotificationMessage(
            NotificationMessage.Command.GETALL_NOTIFICATIONS);

    CalendarClient client = CalendarClient.getInstance();

    Listener listener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof NotificationMessage) {
                NotificationMessage message = (NotificationMessage) object;

                switch (message.getCommand()) {
                    case RECEIVE_NOTIFICATION:
                        Platform.runLater(() -> notifications.addAll(0, message.getNotifications()));
                        break;
                }
            }
        }
    };

    client.addListener(listener);
    client.sendMessage(findNotifications);
}

public FSUIPCKryonetInterface(String server, int port) {
    this.server = server;
    this.port = port;
    // ~
    client = new Client();
    client.start();
    client.addListener(new Listener() {
        public void received (Connection connection, Object object) {
            if(object instanceof String) {
                String message = (String)object;
                if(message.startsWith("CHANGED")) {
                    Collection<OffsetItem> offsetItems = toOffsetItems(message);
                    for(OffsetItem offsetItem : offsetItems) {
                        offsetEventListeners.fire().valueChanged(offsetItem);
                    }
                    offsetCollectionEventListeners.fire().valuesChanged(offsetItems);
                }
            }
        }
    });
    // ~
    offsetEventListeners = EventListenerSupport.create(OffsetEventListener.class);
    offsetCollectionEventListeners = EventListenerSupport.create(OffsetCollectionEventListener.class);
}

private String[] startLobby(){
    final Menu menu = new Menu("lobby");
    client.getClient().addListener(new Listener() {
        public void received (Connection connection, Object object) {
            if (object instanceof Network.Start) {
                menu.action = "continue";
                return;
            }
        }
    });
    client.sendReady();
    String[] menuReturn;
    do {
         menuReturn = menu.render();
        if(menuReturn[0].equals("forceStart")){
            client.sendForceStart();
            client.sendReady();
        }
    }while (!menuReturn[0].equals("continue"));

    return menuReturn;
}

@Override
public void create() {
    try{

        if(true){
            // Run server
            this.server = new Server(22050, 22050);
            server.bind(7777, 7777);
            server.start(); 

            relay = new VoiceChatServer(server.getKryo());

            server.addListener(new Listener(){
                public void received(Connection connection, Object object) {
                    relay.relayVoice(connection, object, server);
                }                   
            });
        }

        this.client = new Client(22050, 22050);
        client.start();
        client.connect(5000, "localhost", 7777, 7777);

        this.sender = new VoiceChatClient(client.getKryo());
        this.sender.addReceiver(client);


    }catch(Exception e){
        e.printStackTrace();
        Gdx.app.exit();
    }   


    // Other stuff for test
    batch = new SpriteBatch();
    font = new BitmapFont();
}

public ClientController(AbstractDiagramController pDiagramController, String pServerIp, int pPort) {
    diagramController = pDiagramController;
    serverIp = pServerIp;
    port = pPort;

    client = new Client();

    initKryo(client.getKryo());

    client.addListener(new Listener() {
        public void received (Connection connection, Object object) {
            if (object instanceof AbstractNode) {
                Platform.runLater(() -> diagramController.createNodeView((AbstractNode)object, true));
            }
            else if (object instanceof AbstractEdge) {
                Platform.runLater(() -> diagramController.addEdgeView((AbstractEdge)object, true));
            }
            else if (object instanceof Graph){
                Graph graph = (Graph) object;
                graph.addRemotePropertyChangeListener(ClientController.this);
                Platform.runLater(() -> diagramController.load(graph, true));
            }
            else if (object instanceof String[]){
                Platform.runLater(() -> diagramController.remoteCommand((String[])object));
            }
        }
    });
}

private void addListeners() {
    client.addListener(new Listener() {
        @Override
        public void received(Connection connection, Object object) {
            if (object instanceof CommandMessage) {
                CommandMessage message = (CommandMessage) object;
                connection.sendTCP(message);
            }
        }
    });
}

private void addListeners() {
    server.addListener(new Listener() {
        @Override
        public void received(Connection connection, Object object) {
            if (object instanceof CommandMessage) {
                CommandMessage message = (CommandMessage) object;
                System.out.println(message);
            }
        }
    });
}

@Override
public synchronized void removeHandlers() {
  final Procedure1<Listener> _function = new Procedure1<Listener>() {
    @Override
    public void apply(final Listener it) {
      NetworkServerImpl.this.server.removeListener(it);
    }
  };
  IterableExtensions.<Listener>forEach(this.listeners, _function);
  this.listeners.clear();
}

private void processEvents(Listener listener, ArrayList<Event> queue) {
    for (Event event: queue) {
        if (event.state == State.CONNECTED) {
            listener.connected(dummyConnection);
        } else if (event.state == State.RECEIVED) {
            listener.received(dummyConnection, event.object);
        } else if (event.state == State.DISCONNECTED) {
            listener.disconnected(dummyConnection);
        }
    }
    queue.clear();
}

private void getAllUsers(int eventId) {
    LocalDate date = datePicker.getValue();
    LocalTime start = toLocalTime(fromTimeField.getText());
    LocalTime end = toLocalTime(toTimeField.getText());

    // If time is not yet set: bail.
    // TODO: Visualize this with a validation.
    if (start == null || end == null) return;

    RequestMessage message = new RequestMessage(RequestMessage.Command.USER_REQUEST, date, start, end, -1);

    CalendarClient client = CalendarClient.getInstance();

    Listener getUsersListener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof ParticipantUserMessage) {
                ParticipantUserMessage complete = (ParticipantUserMessage) object;
                switch (complete.getCommand()) {
                    case RECEIVE_ALL:
                        setAllUsers(complete.getParticipantUsers(), eventId);
                        break;
                    case SEND_ALL:
                        break;
                }
                client.removeListener(this);
            }
        }
    };
    client.addListener(getUsersListener);
    client.sendMessage(message);
}

@FXML
private void submit() {
    AuthMessage testMessage = new AuthMessage(AuthMessage.Command.LOGIN,
            usernameField.getText(), passwordField.getText());

    CalendarClient client = CalendarClient.getInstance();

    Listener loginListener = new Listener() {
        public void received(Connection connection, Object object) {
            if (object instanceof AuthCompleteMessage) {
                AuthCompleteMessage complete = (AuthCompleteMessage) object;

                switch (complete.getCommand()) {
                    case SUCCESSFUL_LOGIN:
                        application.successfulLogin(complete.getUser());
                        break;
                    case UNSUCCESSFUL_LOGIN:
                        // TODO: Show in GUI
                        System.out.println("Ugyldig brukernavn og/eller passord");
                        break;
                }
                client.removeListener(this);
            }
        }
    };

    client.addListener(loginListener);
    client.sendMessage(testMessage);
}

private void initSocket (String serverIp, int port) throws IOException {
    if (InetAddressValidator.getInstance().isValidInet4Address(serverIp) == false) {
        InetAddress address = InetAddress.getByName(serverIp);
        serverIp = address.getHostAddress();
    }

    client = new Client(200000, 200000);
    KryoUtils.registerNetClasses(client.getKryo());
    client.start();

    sender = new ExchangeSender("Client Sender", client);
    pinger = new ExchangePinger(sender, "Client Pinger", new TimeoutListener() {
        @Override
        public void timedOut () {
            postStatus(ConnectionStatus.TIMEDOUT, "Server not responded to ping messages.");
            disconnect(false);
        }
    });

    client.connect(5000, serverIp, port);
    client.addListener(new Listener() {
        @Override
        public void received (Connection connection, Object object) {
            if (object instanceof Exchange) {
                Exchange exchange = (Exchange)object;
                processLater(exchange);
            }
        }
    });
}

/**
 * Contructor
 * 
 * @param connectionParameters
 *          The {@link ConnectionParameters}
 * @param kryoNetParams
 *          KryoNet specific parameters
 */
public KryoNetEventSender(KryoNetConnectionParameters connectionParameters, KryoNetParameters kryoNetParams) {
  super(connectionParameters);
  this.kryoNetParameters = kryoNetParams;
  stats = new EventSenderStats(connectionParameters.getId());
  status = new AtomicReference<KryoNetEventSenderStatus>(KryoNetEventSenderStatus.STOPPED);
  clients = new ReadWriteCircularList<Connection>();
  clientListener = new Listener.ThreadedListener(new Listener() {
    /**
     * @see com.esotericsoftware.kryonet.Listener#connected(com.esotericsoftware.kryonet.Connection)
     */
    @Override
    public void connected(final Connection connection) {
      LOG.debug("Connection (id: {}) from {}", connection.getID(), connection.getRemoteAddressTCP());
      clients.add(connection);
      stats.incrClients();
    }

    /**
     * @see com.esotericsoftware.kryonet.Listener#disconnected(com.esotericsoftware.kryonet.Connection)
     */
    @Override
    public void disconnected(final Connection connection) {
      LOG.debug("Disconnection (id: {})", connection.getID());
      clients.remove(connection);
      stats.decrClients();
    }
  });
}

public RemoteMinecraft(String address) {
    client = new Client(65536, 65536);
    Kryo kryo = client.getKryo();
    kryo.register(NetCreateWorldRequest.class);
    kryo.register(NetGetBiomeDataRequest.class);
    kryo.register(NetGetBiomeDataResult.class);
    kryo.register(NetBiome.class);
    kryo.register(NetBiome[].class);
    kryo.register(NetInfoRequest.class);
    kryo.register(int[].class);

    client.addListener(new Listener() {
        @Override
        public void received(Connection connection, Object object) {
            if (object instanceof NetGetBiomeDataResult) {
                currentResults = (NetGetBiomeDataResult)object;
                //Log.i("Received NetGetBiomeDataResult: " + currentResults);
            } else if (object instanceof NetBiome[]) {
                NetBiome[] biomes = (NetBiome[])object;
                for (int i = 0; i < biomes.length; i++) {
                    if (biomes[i] != null) {
                        new Biome(biomes[i].name, biomes[i].id, biomes[i].color | 0xFF000000, true);
                    }
                }
            }
        }
    });

    client.start();
    try {
        client.connect(5000, address, 54580, 54580);
    } catch (IOException e) {
        e.printStackTrace();
    }

    client.sendTCP(new NetInfoRequest());

}

public NetworkServer(int ID)
{
    id = ID;

    server = new Server();
    serverListener = new NetworkServerListener(new Listener(), this);
    NetworkManager.registerPackets(server.getKryo());

    server.start();
    server.addListener(serverListener);
}

public NetworkClient(int ID)
{
    id = ID;

    client = new Client();
    clientListener = new NetworkClientListener(new Listener(), this);
    NetworkManager.registerPackets(client.getKryo());
    client.addListener(clientListener);
    client.start();
}

public boolean createMotorEndpoint(Port port, Motors motortype, int networkPort) throws IOException {
    if(endpoints.containsKey(port)){
        //Ports bereits offen
        if(((MotorEndpoint)endpoints.get(port)).getMotor() != null) {
            if(((MotorEndpoint)endpoints.get(port)).getMotor().getMotortype() == motortype){
                return true;
            }
            System.out.println("Motor.createMotorEndpoint() at "+port.toString()+" -> aktueller motortyp passt nicht");
        }

        ((MotorEndpoint)endpoints.get(port)).getMotor().close();//TODO
        System.out.println("Motor.createMotorEndpoint() at "+port.toString()+" -> aktueller motortyp passt nicht - erzeuge neuen motortyp");
        switch(motortype){
            case UnregulatedMotor:
                ((MotorEndpoint)endpoints.get(port)).setMotor(new EV3UnregulatedMotor(port));
                return true;
            case MediumRegulatedMotor:
                ((MotorEndpoint)endpoints.get(port)).setMotor(new MediumRegulatedMotor(port));
                return true;
            case LargeRegulatedMotor:
                ((MotorEndpoint)endpoints.get(port)).setMotor(new LargeRegulatedMotor(port));
                return true;
            default: return false;
        }
    }

    Listener endpoint = null;

    switch(motortype){
        case UnregulatedMotor:
            endpoint = new MotorEndpoint(new EV3UnregulatedMotor(port));
            break;
        case MediumRegulatedMotor:
            endpoint = new MotorEndpoint(new MediumRegulatedMotor(port));
            break;
        case LargeRegulatedMotor:
            endpoint = new MotorEndpoint(new LargeRegulatedMotor(port));
            break;
        default: return false;
    }

    if(endpoint != null){
        endpoints.put(port,endpoint);

        //Create Server for Motor //TODO remove to ServerBuilder/-Manager.class
        BrickServerImpl brickServer = new BrickServerImpl(networkPort);
        brickServer.addListener(endpoint);

        return true;
    }else{
        return false;
    }

}

public HardwareInterfaceManager(BrickType bType){
    this.bType = bType;
    //this.app = app;
    endpoints = new HashMap<Port,Listener>(8);
    ports = new ArrayList<Port>(4);
}

@Override
public void addListener(Listener listener){
    server.addListener(listener);
    //listener.registerMessages(server);
}

public void addListener(Listener listener) {
    client.addListener(listener);
}

/**
 * Method used to try to connect the client at the server.
 */
private void connect() {
    client.addListener(new Listener() {
        public void received(Connection connection, Object object) {
            if (state == 3) {
                if (object instanceof Game) {
                    Game game = (Game) object;
                    if (game.getGameN() == 0) {
                        game.setGameN(1);
                        new WindowGame((Game) object, client, Oplayer);
                        state = 2;
                        state();
                    }
                }
            }
            if (object instanceof String) {
                if (((String) object).equals("FULL")) {
                    JOptionPane
                            .showMessageDialog(
                                    null,
                                    "Connexion impossible, le serveur est plein, veuillez patienter",
                                    "Serveur plein",
                                    JOptionPane.INFORMATION_MESSAGE);
                    close();
                }
                if (((String) object).equals("GO")) {
                    state = 2;
                    state();
                    new InitWindow(stratclient, Oplayer);

                }

            }
            if (object instanceof Integer) {
                if ((Integer) object == 1) {
                    state = 1;
                    state();
                }
                if ((Integer) object == 2) {
                    state = 2;
                    state();
                }
                if ((Integer) object == -1) {
                    Oplayer = 1;
                }
                if ((Integer) object == -2) {
                    Oplayer = 2;
                }
            }
        }

    });
    client.start();

    try {
        client.connect(5000, adIp, 54555, 54777);
    } catch (IOException e) {
        JOptionPane.showMessageDialog(null,
                "Connexion impossible, veuillez verifier l'adresse.",
                "Erreur", JOptionPane.ERROR_MESSAGE);
        askIp();
        connect();
    }

}

/**
 * Constructor of the class when the game is online.
 * 
 * @param ngame
 *            The 'game' object of the current game.
 * 
 * @param client
 *            The client object used to communicate with the server.
 * 
 * @param Oplayer
 *            The number of this player: 1 or 2.
 */
public WindowGame(Game ngame, Client client, int Oplayer) {
    this(ngame);
    this.game.setGameN(1);
    this.client = client;
    this.Oplayer = Oplayer;
    client.addListener(new Listener() {
        @SuppressWarnings("static-access")
        public void received(Connection connection, Object object) {
            if (object instanceof Game) {
                if (game.getGameN() == 1) {
                    game = (Game) object;
                    pane.recupGame(game);

                    repaint();
                    int result = game.win();
                    if (result != 0) {
                        pane.setView(0);
                        playGame = false;
                        repaint();

                        jopWin = new JOptionPane();
                        jopWin.showMessageDialog(null, "Le joueur "
                                + resultName[result - 1] + " gagne !",
                                "Resultat", JOptionPane.INFORMATION_MESSAGE);
                        clientClose();
                    }
                }

            }
            if (object instanceof int[]) {
                int[] res = (int[]) object;

                APawn pawn = game.getPawn(res[0], res[1]);
                pawn.setShow(!pawn.getShow());
                pane.recupGame(game);
                pane.repaint();
            }
        }
    });
    this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    pane.setView(Oplayer);
    pane.recupGame(game);

    repaint();
}

public void setOutgoingEventListener(Listener listener) {
    outgoingEventListener = listener;
}

public void addListener(Listener listener) {
    client.addListener(listener);
}

public void removeListener(Listener listener) {
    client.removeListener(listener);
}

public StoppableThreadedListener (Listener listener) {
    super(listener);
}

private void startClientListening(final StateBasedGame sbg){
    client.addListener(new Listener() {
        @SuppressWarnings("unchecked")
        public void received (Connection connection, Object object) {

            if (object instanceof NetworkFormat) {
                NetworkFormat netObject = (NetworkFormat) object;
                String dataName = netObject.data_name;
                   Object dataObject = netObject.data;

                   switch (dataName){
                       case "PLAYERLIST":
                           if (netObject.privat) {
                               System.out.println("set players from server");
                               Play.players = (ArrayList<Player>) netObject.data;
                           }else{
                               // Enter lobby
                               System.out.println("enter client lobby");
                               playerList = (HashMap<Integer, String>) netObject.data;
                               //   playerList.add(Game.username);
                               menuToRender = 2;
                           }
                           break;
                       case "HOSTDISCONNECTED":
                           // Exit lobby
                           showHostDC();
                           break;
                       case "OK":
                           // Good to join
                           System.out.println("Good to join");
                           Network.playerID = (int)dataObject;
                           break;
                       case "ID":
                           // Set pid
                           Network.playerID = (int)dataObject;
                           System.out.println("Set id to: "+Network.playerID);
                           break;
                       case "START_GAME":
                           // Host started game
                           sbg.enterState(Game.play);
                           client.removeListener(this);
                           break;


                   }
            }   
        }
    });
}

public ChatRmiClient () {
    client = new Client();
    client.start();

    // Register the classes that will be sent over the network.
    Network.register(client);

    // Get the Player on the other end of the connection.
    // This allows the client to call methods on the server.
    player = ObjectSpace.getRemoteObject(client, Network.PLAYER, IPlayer.class);

    client.addListener(new Listener() {
        public void disconnected (Connection connection) {
            EventQueue.invokeLater(new Runnable() {
                public void run () {
                    // Closing the frame calls the close listener which will stop the client's update thread.
                    chatFrame.dispose();
                }
            });
        }
    });

    // Request the host from the user.
    String input = (String)JOptionPane.showInputDialog(null, "Host:", "Connect to chat server", JOptionPane.QUESTION_MESSAGE,
        null, null, "localhost");
    if (input == null || input.trim().length() == 0) System.exit(1);
    final String host = input.trim();

    // Request the user's name.
    input = (String)JOptionPane.showInputDialog(null, "Name:", "Connect to chat server", JOptionPane.QUESTION_MESSAGE, null,
        null, "Test");
    if (input == null || input.trim().length() == 0) System.exit(1);
    final String name = input.trim();

    // The chat frame contains all the Swing stuff.
    chatFrame = new ChatFrame(host);
    // Register the chat frame so the server can call methods on it.
    new ObjectSpace(client).register(Network.CHAT_FRAME, chatFrame);
    // This listener is called when the send button is clicked.
    chatFrame.setSendListener(new Runnable() {
        public void run () {
            player.sendMessage(chatFrame.getSendText());
        }
    });
    // This listener is called when the chat window is closed.
    chatFrame.setCloseListener(new Runnable() {
        public void run () {
            client.stop();
        }
    });
    chatFrame.setVisible(true);

    // We'll do the connect on a new thread so the ChatFrame can show a progress bar.
    // Connecting to localhost is usually so fast you won't see the progress bar.
    new Thread("Connect") {
        public void run () {
            try {
                client.connect(5000, host, Network.port);
                // Server communication after connection can go here, or in Listener#connected().
                player.registerName(name);
            } catch (IOException ex) {
                ex.printStackTrace();
                System.exit(1);
            }
        }
    }.start();
}

@Override
protected Void doInBackground() throws Exception {
    final int BUFFER_SIZE = 10000;
    Client client = new Client(BUFFER_SIZE, BUFFER_SIZE);

    client.getKryo().register(PacketLogin.class);
    client.getKryo().register(PacketLoginResponse.class);
    client.getKryo().register(PacketRequestCaptcha.class);
    client.getKryo().register(PacketCaptchaImage.class);
    client.getKryo().register(byte[].class);
    client.getKryo().register(PacketRegister.class);
    client.getKryo().register(PacketRegistered.class);
    client.getKryo().register(PacketFilesListRequest.class);
    client.getKryo().register(PacketFilesList.class);
    client.getKryo().register(String[].class);


    client.addListener(new Listener() {
        @Override
        public void received(Connection connection, Object object) {
            if (object instanceof PacketFilesList) {
                PacketFilesList response = (PacketFilesList) object;
                System.out.println("[Sync] Got files: " + response.numFiles + " | " + response.files);

                publish(new FilesListState(response));

                connection.close();
            }
        }
    });

    client.start();

    try {
        client.connect(5000, Constants.SERVER_HOST, Constants.SERVER_PORT);
    } catch (Exception e) {
        e.printStackTrace();

        return null;
    }

    Thread.sleep(1000);
    PacketFilesListRequest req = new PacketFilesListRequest();
    req.clientPrefix = this.prefix;

    client.sendTCP(req);


    return null;
}

@Override
protected Void doInBackground() throws Exception {
    final int BUFFER_SIZE = 64000;
    Client client = new Client(BUFFER_SIZE, BUFFER_SIZE);

    client.getKryo().register(PacketLogin.class);
    client.getKryo().register(PacketLoginResponse.class);
    client.getKryo().register(PacketRequestCaptcha.class);
    client.getKryo().register(PacketCaptchaImage.class);
    client.getKryo().register(byte[].class);
    client.getKryo().register(PacketRegister.class);
    client.getKryo().register(PacketRegistered.class);
    client.getKryo().register(PacketFilesListRequest.class);
    client.getKryo().register(PacketFilesList.class);
    client.getKryo().register(String[].class);
    client.getKryo().register(PacketChangePassword.class);
    client.getKryo().register(PacketChangePasswordResponse.class);
    client.getKryo().register(PacketWLRequestRealm.class);
    client.getKryo().register(PacketWLData.class);
    client.getKryo().register(PacketAddItemToWL.class);
    client.getKryo().register(PacketBadWLItems.class);

    client.start();

    client.addListener(new Listener() { 
        @Override
        public void received(Connection connection, Object object) {
            connection.close();
        }            
    });

    try {
        client.connect(5000, Constants.SERVER_HOST, Constants.SERVER_PORT);
    } catch (Exception e) {
        e.printStackTrace();

        return null;
    }

    PacketAddItemToWL packet = new PacketAddItemToWL();
    packet.item = this.item;
    packet.session = this.session;
    packet.username = this.username;
    packet.prefix = ConfigManager.getInstance().getClientPrefix();

    client.sendTCP(packet);

    return null;
}