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

private synchronized void onNewConnection(Connection con) {
    Gdx.app.log("Server", "Client connected");

    Player p = PlayerUtils.getRandomPlayer(players.values());
    players.put(playersJoinedCount, p);
    clients.put(playersJoinedCount, new ServerPlayer(p));
    connections.put(playersJoinedCount, con);

    // Inform the other clients
    server.sendToAllExceptTCP(con.getID(), new PlayerJoinedMessage(
            playersJoinedCount, players.get(playersJoinedCount)));

    // Send the setup response
    con.sendTCP(
            new GameSetupMessage(players, playersJoinedCount, settings));

    playersJoinedCount++;
}

private GameResponse getRandomGame(Connection connection, Account account) {
    Game randomGame = null;
    // Go through the games
    if (gamesMap != null) {
        for (Game game : gamesMap.values()) {
            // If there's a game currently waiting for more players, that's the one to return
            if (!game.isInProgress() && game.getPlayerCount() < Config.MAX_PLAYERS) {
                // Add the player to the game
                game.addPlayer(account, connection.getID());
                gamesMap.put(account.getUsername(), game);
                randomGame = game;
            }
        }
    }
    return GameResponse.newInstance(randomGame);
}

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);
                    }
                });
            }
        }
    };
}

private void handleCreateMotorMessage(final Connection conn, final CreateMotorMessage msg) {
    Thread createMotor = new Thread(){
        @Override
        public void run(){
            LocalEV3.get().getLED().setPattern(9);

            if(motorPorts.containsKey(msg.getPort())){
                if(createMotorEndpoint( motorPorts.get(msg.getPort()),msg.getMotorType(),msg.getNetworkPort() )){
                    conn.sendTCP(BrickMessages.createEndpointCreatedMessage(true, msg.getPort(), "Motor endpoint created: "+msg.getPort(), false, true));       
                }else{
                    isBlocked = true;
                    System.out.println("System got blocked by handleCreateMotorMethod");
                    conn.sendTCP(BrickMessages.createEndpointCreatedMessage(false, msg.getPort(), "Motor endpoint not created: "+msg.getPort(), false, true));                      

                }
            }else{
                conn.sendTCP(BrickMessages.createEndpointCreatedMessage(false, msg.getPort(), "Port not found!"+msg.getPort(), false, true));
            }   
        }
        };
    creationThreads.add(createMotor);
    //createMotor.start();
}

@Override
  public void received(Connection connection, Object object){
/** Message if the Endpoint-creation was successful or not **/
    System.out.println("Local-EV3MotorManager: received a message!");

if(object.getClass() == BrickMessages.EndpointCreatedMessage.class){
    BrickMessages.EndpointCreatedMessage ecmsg = (BrickMessages.EndpointCreatedMessage)object;
    System.out.println("Local-EV3MotorManager: Received a EndpointCreatedMessage! -> "+ecmsg.toString());
    if(ecmsg.isMotor()){
        if(ecmsg.isSuccess()){
            System.out.println("Local-EV3MotorManager: isSuccess at port "+ecmsg.getPort()+"#");
            if(motors.containsKey(EV3MotorPort.getPort(ecmsg.getPort()))){
                System.out.println("Local-EV3MotorManager: Endpoint creation successfull - connect to endpoint!");
                endpoints.get(EV3MotorPort.getPort(ecmsg.getPort())).connect();
            }else{
                System.out.println("Local-EV3MotorManager: Sensor does not exist");
            }
        }else{
            //TODO Tell Sensor/Motor Manager that endpoint creation failed
        }
    }
}
  }

@Override
public void received(Connection connection, Object object) {
    System.out.println("Local-EV3Display: Received Message "+object.toString());
    if(object.getClass() == BrickMessages.EndpointCreatedMessage.class){
        BrickMessages.EndpointCreatedMessage msg = (EndpointCreatedMessage) object;
        if(!msg.isMotor() && !msg.isSensor()){
            if(msg.isSuccess() && msg.getMsg().equals("DISPLAY")){
                connect();
                System.out.println("EV3-Display: connecting to endpoint!");
            }
        }
        return;
    }

    if(object.getClass() == DisplayMessages.HelloDisplay.class){
        ready = true;
    }

}

@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);
            }
        }           
    });
}

@Override
public void handle(Connection connection, RetrieveItemRewardPacket packet)
{
    Character character = gameDataRetreiver.getUserCharacterByConnectionId(connection.getID());
    CharactersQuests quest = findSuiteQuest(character.getQuests(), packet.getQuestName());
    CharactersQuestsItemReward itemReward = findSuiteItemReward(quest.getItemsReward(), packet.getItemIdentifier());
    PlayerCharacter player = (PlayerCharacter) gameContainer.getObject(character.getId());
    InventoryPosition inventoryPosition = new InventoryPosition(packet.getDesiredInventoryPage(),
            packet.getDesiredInventoryX(), packet.getDesiredInventoryY());
    Item gameItem;
    if (itemReward.getNumberOfItems() == packet.getNumberOfItems())
        gameItem = GameItemsFactory.produce(itemReward.getItemIdentifier(), itemReward.getNumberOfItems(),
                IdSupplier.getId(), inventoryPosition);
    else
        throw new NotImplementedException("Not implemented yet");

    player.addItemAllowStacking(gameItem);
    connection.sendTCP(PacketsMaker.makeItemRewardRemovePacket(packet.getItemIdentifier(),
            itemReward.getNumberOfItems()));
    connection.sendTCP(PacketsMaker.makeItemPacket(gameItem));
}

@Override
public void handle(Connection connection, RetrieveGoldRewardPacket packet)
{
    Character character = gameDataRetriever.getUserCharacterByConnectionId(connection.getID());
    CharactersQuests quest = findSuiteQuest(character.getQuests(), packet.getQuestName());
    int goldReward = quest.getGoldReward();
    if (goldReward > 0)
    {
        quest.setGoldReward(0);
        character.setGold(character.getGold() + goldReward);
        packetsSender.sendTo(connection.getID(), PacketsMaker.makeGoldReceivePacket(goldReward));
        packetsSender.sendTo(connection.getID(),
                PacketsMaker.makeQuestRewardGoldRemovalPacket(goldReward));
    } else
        packetsSender.sendTo(connection.getID(),
                PacketsMaker.makeUnacceptableOperationPacket("There is no gold left!"));

}

private void clientBoardClickProperHandle(Connection connection, GameObject target, PlayerCharacter source)
{
    // TODO: refactor, implement collicion detection on clent side, so he 
    // can tell what he wants to do directly
    if (target instanceof ShopNpc)
        sendShopItemsInfo(connection, (ShopNpc) target);
    else if (target instanceof QuestDialogNpc)
        propagateQuestDialogEvent((QuestDialogNpc) target, source);
    else if (target instanceof Monster)
        tryToTargetMonster(connection, (Monster) target, source);
    else if (target instanceof QuestBoard)
        sendQuestBoardInfo(connection, (QuestBoard) target);
    else if (target.getClass().getSimpleName().contains("NullGameObject"))
        ;//ignore
    else
        throw new NotImplementedException("Not implemented");

}

@Override
public void handle(Connection connection, ItemUsagePacket packet)
{
    int characterId = gameData.getCharacterIdByConnectionId(connection.getID());
    PlayerCharacter itemUser = (PlayerCharacter)playState.getObject(characterId);
    if(itemUser == null)
        throw new PlayerUsingItemNotFoundException();
    Monster target = (Monster)playState.getObject(packet.getTargetId());
    try
    {
        itemUser.useItem(packet.getItemId(), target, (PacketsSender)playState);
        connection.sendTCP(packet);
    }
    catch(OutOfStockException e)
    {
        connection.sendTCP(PacketsMaker.makeUnacceptableOperationPacket("Your item stack was depleted"));
    }
}

@Override 
public void handle(Connection connection, TakingGoldFromContainerPacket packet)
{
    long characterId = gameData.getCharacterIdByConnectionId(connection.getID());
    PlayerCharacter player = (PlayerCharacter)playState.getObject(characterId);
    GameContainer container = playState.getContainer(packet.getContainerId());
    int gold = container.getGoldAmount();
    if(gold > 0)
    {
        connection.sendTCP(PacketsMaker.makeGoldReceivePacket(gold));
        server.sendToAllTCP(PacketsMaker.makeContainerGoldRemovalPacket(packet.getContainerId(), gold));
        container.setGoldAmount(0);
        player.addGold(gold);
    }
    else
        connection.sendTCP(PacketsMaker.makeUnacceptableOperationPacket("There is no gold left in this container"));

}

@Override
public void handle(Connection connection, ScriptCodePacket packet)
{
    User user = authenticatedClientsKeyClientId.get(connection.getID());
    if(!user.getRole().equals(UserRole.ADMIN))
    {
        connection.sendTCP(PacketsMaker.makeScriptExecutionErrorPacket("You must be admin to do that"));
        return;
    }

    try
    {
        Object result = playState.executeCode(packet.getCode(), user.getId());
        if(result != null)
            connection.sendTCP(PacketsMaker.makeScriptResultInfoPacket(result.toString()));

    }catch(ScriptException e)
    {
        connection.sendTCP(PacketsMaker.makeScriptExecutionErrorPacket(e.getMessage()));
    }
}

@Override
public void handle(Connection connection, ChatMessagePacket packet)
{
    Field connectionsField = FieldUtils.getField(Server.class, "connections", true);

    Connection[] connections;
    try
    {
        connections = (Connection[])FieldUtils.readField(connectionsField, server, true);
    } catch (IllegalAccessException e)
    {
        throw new RuntimeException(e);
    }
    ChatMessageReplyPacket newPacket = new ChatMessageReplyPacket();
    Character sender = gameData.getUserCharacterByConnectionId(connection.getID());
    String nickname = sender.getNickname();
    newPacket.setMessage(packet.getMessage());
    newPacket.setNickname(nickname);
    Character character;
    for(Connection client : connections)        
        if((character = gameData.getUserCharacterByConnectionId(client.getID())) != null)
        {
            newPacket.setSourceCharacterId(character.getId());
            server.sendToTCP(client.getID(), newPacket);
        }
}

private void userChoosenCharcter(int userCharacterId, Connection connection)
{
    Character character = characterRepo.findOneAndFetchEverythingRelated(userCharacterId);

    UserInfo info = loggedUsersKeyUserId.get(character.getUser().getId());
    info.userCharacter = character;
    int clientId = connection.getID();
    sendCurrentGameObjectsInfo(connection);
    PlayerCharacter newPlayer = new PlayerCharacter(character, playState, clientId);
    Collection<Item> playerItems = getPlayerItems(newPlayer);
    playerItems.forEach((item) -> newPlayer.addItemDenyStacking(item));
    playState.add(newPlayer);
    server.sendToAllExceptTCP(clientId, PacketsMaker.makeCreationPacket(newPlayer));
    sendItemsDataToClient(playerItems, connection);
    sendItemQuickAccessBarConfigToClient(character.getItemQuickAccessBarConfig().values(), connection);
    sendSpellQuickAccessBarConfigToClient(character.getSpellQuickAccessBarConfig().values(), connection);
    sendQuestInfoToClient(character.getQuests(), connection);
    sendAvailableSpellsToClient(character.getSpells(), connection);
}

@Override
public void handle(Connection connection, BuyFromShopPacket packet)
{
    ShopNpc shopNpc = (ShopNpc) playState.getObject(packet.getShopId());
    ShopItemWrapper itemWrapper = shopNpc.getItemWrapper(packet.getItemId());
    Character userCharacter = gameData.getUserCharacterByConnectionId(connection.getID());
    PlayerCharacter character = (PlayerCharacter) playState.getObject(userCharacter.getId());

    int itemCount = packet.getAmount();
    int singleItemPrice = itemWrapper.getPrice();
    int totalPrice = singleItemPrice * itemCount;
    int characterGold = character.getProperties().gold;
    if (totalPrice > characterGold)
        connection.sendTCP(PacketsMaker.makeUnacceptableOperationPacket("You don't have enough gold!"));
    else
    {
        handleGoldPart(connection, totalPrice, character);
        InventoryPosition position = new InventoryPosition(packet.getDesiredInventoryPage(),
                packet.getDesiredInventoryX(), packet.getDesiredInventoryY());
        handleItemPart(connection, itemWrapper, character, itemCount, position);
    }
}

private void userLoggedOut(Connection connection)
{
    User user = authenticatedClientsKeyClientId.remove(connection.getID());
    Character userCharacter = loggedUsersKeyUserId.remove(user.getId()).userCharacter;
    if (userCharacter != null)
    {
        int characterId = userCharacter.getId();
        if (playState.has(characterId))
        {
            GameObject removedCharacter = playState.remove(characterId);
            new CharacterDatabaseSaver().save((PlayerCharacter)removedCharacter);
            server.sendToAllExceptTCP(connection.getID(), PacketsMaker.makeRemovalPacket(characterId));
        }
        playState.removeGameCommandsHandler(user.getId());
    }
}

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));
            }
        }
    });
}

@Override
public void handle(final Client client, Connection connection, Command command) {
    model.getClient().ifPresent(c -> {
        if (c == client) {
            model.getMessages().add("Server " + model.getServer() + ":" + model.getPort() + " is no longer available.");
            client.stop();
            try {
                client.dispose();
            } catch (IOException ignored) {
                // OK
            }
            model.setClient(null);
            model.setConnected(false);
            model.getMessages().clear();
        }
    });
}

@Override
public void received(Connection connection, Object o) {
    if(!(o instanceof Message)){
        return;
    }
    Message msg = (Message) o;
    switch (msg.getMessageCode()){
        case MessageCodes.CLIENT_NAME:
            Client client = players.get(players.indexOf(new Client(connection.getID())));
            client.setName(((GeneralMessage)msg).getMessage());
            ++namesSet;
            if (serverIsFull && namesSet == MAX_CLIENTS){
                GameData.setPlayersReady(true);
            }
            break;
    }
}

@Override
public void handle(Connection connection, Object object) {

    if(!(object instanceof Message)){
        return;
    }

    Message message = (Message) object;

    switch (message.getMessageCode()){
        case MessageCodes.CLIENT_NAME:
            GeneralMessage msg = (GeneralMessage) message;
            connection.setName(msg.getMessage());
            break;

    }
}

@Override
public void handle(Connection connection, Object object) {

    if(!(object instanceof Message)){
        return;
    }

    Message message = (Message) object;

    switch (message.getMessageCode()){
        case MessageCodes.SERVER_FULL:
            ////////////////////////////
            break;

    }
}

@Override
public void connected(Connection connection) {

    if (getWorld().isGameOver() ||
            (getWorld().getPlayers().size() >= 2 &&
            Parameters.restrictJoin)) {
        sendEventToPlayer(Event.ON_CONNECTION_REFUSED, -1, connection.
                getID());
        return;
    }

    final int playerID = connection.getID();
    ((ServerWorld) world).addPlayer(playerID);
    sendStateToPlayer(playerID);
    sendTileUpdateToPlayer(playerID);
    System.out.println("Client connected! ID# " + playerID);
}

@Override
public void disconnected(Connection connection) {
    System.out.println("disconnected from server!");

    if (error == ErrorCode.NOREASON) {
        error = ErrorCode.SERVER_DISCONNECTED;

        Gdx.app.postRunnable(new Runnable() {
            @Override
            public void run() {
                GameScreen screen = new ScreenMainMenu();
                CoreBC.changeScreen(screen);
            }
        });
    }
}

@Override
public void received(final Connection connection, final Object object) {
  if (object instanceof Size) {
    final Size size = (Size) object;
    final long tod = size.tod;
    final int msgs = size.messages;
    final Price price = new Price();
    for (int i = 0; i < msgs; i++) {
      price.tod = tod;
      price.iid = i;
      price.bid = 2;
      price.ask = 3;
      price.trd = 4;
      price.vol = 5;
      while (!connection.isIdle()) {
        // busy spin waiting for space in buffer
      }
      connection.sendTCP(price);
    }
  }
}

@Override
public void sendStreamTo (Object connectionInformation, InputStream stream, int size, String type,
    Object additionalInformation) {

    final int streamId = (int)(Math.random() * Integer.MAX_VALUE);

    Packet.StreamHeader streamHeader = new Packet.StreamHeader();
    streamHeader.additionalInfo = additionalInformation;
    streamHeader.streamId = streamId;
    streamHeader.type = type;
    streamHeader.streamLength = size;
    sendTo(connectionInformation, streamHeader, true);

    // Send data in 512 byte chunks.
    ((Connection)connectionInformation).addListener(new InputStreamSender(stream, 1024) {
        @Override
        protected Object next (byte[] bytes) {
            Packet.StreamChunk chunkPacket = new Packet.StreamChunk();
            chunkPacket.streamId = streamId;
            chunkPacket.chunkBytes = bytes;
            return chunkPacket;
        }
    });
}

@Override
public void received (Connection connection, final Object object) {
    if(!(object instanceof Packet))
        return;
    Packet packet = ((Packet)object);

    if (packet instanceof Packet.LobbyPacket) {
        if (packet instanceof Packet.SetLobbyData)
            layer.net.lobby.values.put(((Packet.SetLobbyData)packet).key, ((Packet.SetLobbyData)packet).value);
        if (packet instanceof Packet.DeleteLobbyData)
            layer.net.lobby.values.remove(((Packet.DeleteLobbyData)packet).key);
        return;
    }

    if (packet instanceof Packet.LoginAnswer) {
        layer.net.lobby.playerJoined(connection, "quexten");
        layer.net.lobby.ownId = ((Packet.LoginAnswer)packet).id;
        HookApi.postHooks(layer.net.lobby.onJoinedHooks, layer.net.lobby.getPlayerForConnection(connection));
    }

    if (layer.net.lobby != null)
        layer.recieve(packet);
}

@Override
public void received (final Connection connection, Object object) {
    if(!(object instanceof Packet))
        return;
    Packet packet = ((Packet)object);

    if (packet instanceof Packet.LoginRequest)
        if (layer.net.lobby.checkPassword(((Packet.LoginRequest)packet).password)) {
            Debug.logDebug(LOG_TAG, "Authentification of " + connection.getRemoteAddressTCP() + " successful as: "
                + ((Packet.LoginRequest)packet).username);

            trustedConnections.add(connection.getID());

            Packet.LoginAnswer answer = new Packet.LoginAnswer();
            answer.id = layer.net.lobby.players.size;
            layer.net.lobby.playerJoined(connection, ((Packet.LoginRequest)packet).username).send(answer, true);

            HookApi.postHooks(layer.net.lobby.onJoinedHooks, layer.net.lobby.getPlayerForConnection(connection));
        } else {
            Debug.log(LOG_TAG, "Authentification failed for " + connection.getRemoteAddressTCP());
            connection.close();
        }
    if (trustedConnections.contains(connection.getID()))
        layer.recieve(packet);
}

private void updateClientDetails(Connection connection, Object object) {
    int version = ((ClientDetailsMessage)object).protocolVersion;
    if (version != Constants.PROTOCOL_VERSION) {
        ServerStatusMessage message = new ServerStatusMessage();
        message.status = Status.DISCONNECT;
        if (version > Constants.PROTOCOL_VERSION) {
            message.toastText = "Please update server";
        } else if (version < Constants.PROTOCOL_VERSION) {
            message.toastText = "Please update client";
        }
        server.sendToTCP(connection.getID(), message);
        return;
    }

    playerList.get(connection.getID()).
    setName(((ClientDetailsMessage) object).name);
    PlayerNamesMessage players = new PlayerNamesMessage();
    for (ServerPlayer tempPlayer: playerList.values()) {
        players.players.put(tempPlayer.id, tempPlayer.getName());
    }
    if (server != null)
        server.sendToAllTCP(players);
    addOutgoingEvent(MessageObjectPool.instance.eventPool.obtain().
            set(State.RECEIVED, players));
}

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);
}

/**
 * forwards a message to apropriate handle method for that message
 * @param conn a connected client
 * @param m the Message with an attached object
 */
private void handleMessageWithObject(Connection conn, MessageWithObject m) {

    switch (m.message) {
        case NEW_TEAMNAME:
            handleNewTeamName(conn, (String) m.object);
            break;
        case TRANSFER_SOURCES:
            receiveSourceFromTeam(conn, m);
            break;
        case CHUNKED_TRANSFER:
            handleNewChunkedTransfer(conn, m);
            break;
        case CHUNK:
            handleChunk(conn, m);
            break;
        case TRANSFER_ERROR:
            handleTransferError(conn, m);
            break;
        default:
            log.info("Received unknown message from" + connectedTeams.get(conn));
    }
}

@Override
public void received(Connection connection, Object object) {
    if (object instanceof GameStateMessage) {
        addNewState((GameStateMessage) object);
    } else if (object instanceof Short) {
        if(world.get(object) != null ) {
            world.get(object).destroy = true;
            //FIXME Set remove in the client entity
            if (!(world.get(object) instanceof ClientBomb))
                world.get(object).remove = true;
        }
    } else if (object instanceof AudioMessage) {
        audioPlayer.playAudioMessage((AudioMessage) object);
    } else if (object instanceof PlayerNamesMessage) {
        this.playerNames = (PlayerNamesMessage) object;
    } else if (object instanceof ServerStatusMessage) {
        ServerStatusMessage message = (ServerStatusMessage) object;
        toaster.toast(message.toastText);
        disconnected = true;
    } else if (object instanceof String) {
        toaster.toast((String) object);
    }
    super.received(connection, 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;
    }
}

/** Returns the first object registered with the specified ID in any of the ObjectSpaces the specified connection belongs to. */
static Object getRegisteredObject (Connection connection, int objectID) {
    ObjectSpace[] instances = ObjectSpace.instances;
    for (int i = 0, n = instances.length; i < n; i++) {
        ObjectSpace objectSpace = instances[i];
        // Check if the connection is in this ObjectSpace.
        Connection[] connections = objectSpace.connections;
        for (int j = 0; j < connections.length; j++) {
            if (connections[j] != connection) continue;
            // Find an object with the objectID.
            Object object = objectSpace.idToObject.get(objectID);
            if (object != null) return object;
        }
    }
    return null;
}

public void received (final Connection connection, Object object) {
    if (!(object instanceof InvokeMethod)) return;
    if (connections != null) {
        int i = 0, n = connections.length;
        for (; i < n; i++)
            if (connection == connections[i]) break;
        if (i == n) return; // The InvokeMethod message is not for a connection in this ObjectSpace.
    }
    final InvokeMethod invokeMethod = (InvokeMethod)object;
    final Object target = idToObject.get(invokeMethod.objectID);
    if (target == null) {
        if (WARN) warn("kryonet", "Ignoring remote invocation request for unknown object ID: " + invokeMethod.objectID);
        return;
    }
    if (executor == null)
        invoke(connection, target, invokeMethod);
    else {
        executor.execute(new Runnable() {
            public void run () {
                invoke(connection, target, invokeMethod);
            }
        });
    }
}

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);
}

public void received (final Connection connection, Object object) {
    if (!(object instanceof InvokeMethod)) return;
    if (connections != null) {
        int i = 0, n = connections.length;
        for (; i < n; i++)
            if (connection == connections[i]) break;
        if (i == n) return; // The InvokeMethod message is not for a connection in this ObjectSpace.
    }
    final InvokeMethod invokeMethod = (InvokeMethod)object;
    final Object target = idToObject.get(invokeMethod.objectID);
    if (target == null) {
        if (WARN) warn("kryonet", "Ignoring remote invocation request for unknown object ID: " + invokeMethod.objectID);
        return;
    }
    if (executor == null)
        invoke(connection, target, invokeMethod);
    else {
        executor.execute(new Runnable() {
            public void run () {
                invoke(connection, target, invokeMethod);
            }
        });
    }
}

/** Returns the first object registered with the specified ID in any of the ObjectSpaces the specified connection belongs to. */
static Object getRegisteredObject (Connection connection, int objectID) {
    ObjectSpace[] instances = ObjectSpace.instances;
    for (int i = 0, n = instances.length; i < n; i++) {
        ObjectSpace objectSpace = instances[i];
        // Check if the connection is in this ObjectSpace.
        Connection[] connections = objectSpace.connections;
        for (int j = 0; j < connections.length; j++) {
            if (connections[j] != connection) continue;
            // Find an object with the objectID.
            Object object = objectSpace.idToObject.get(objectID);
            if (object != null) return object;
        }
    }
    return null;
}

public boolean onPacketReceived(Connection connection, Object packet) {
    Iterator<Class> it = mPackets.keySet().iterator();

    while (it.hasNext()) {
        Class item = it.next();
        try {
            if (packet.getClass().isAssignableFrom(item)) {
                PacketAction a = mPackets.get(item);
                AccountConnection c = (AccountConnection)connection;
                if (!a.needLoggedIn() || (c.getToken() != null && c.getToken().length() > 0)) {
                    a.run(c, packet);
                } else {
                    ErrorPacket p = new ErrorPacket();
                    p.message = "You are not authenticated.";
                    p.status = ErrorType.NOT_AUTHENTICATED;
                    c.sendTCP(p);
                    c.close();
                }
                return true;
            }
        } catch (Exception e) {
            Log.error("PacketInterpretator", e);
        }
    }
    return false;
}