/// <summary> /// Read and prosess data from stream /// </summary> private void ClientStreamReadData() { try { using (Stream stream = _server.GetStream()) { BinaryReader streamReader = new BinaryReader(stream); while (true) { PacketType packetType = (PacketType)streamReader.ReadInt32(); switch (packetType) { case PacketType.Negotiation: NegotiationPacket negotiationPacket = new NegotiationPacket(stream); negotiationPacket.Receive(); Login = negotiationPacket.Login; _loginEvents[0].Set(); _registerEvents[0].Set(); lock (_rooms) { Room mainRoom = new Room(Room.MainRoomId, Room.MainRoomName, new HashSet <string>()); _rooms.Add(Room.MainRoomId, mainRoom); } _context.Post(p => NegotiationCompleted?.Invoke(this, EventArgs.Empty), null); break; case PacketType.SimpleMessage: SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream); simpleMessagePacket.Receive(); OnSimpleMessageReceived(simpleMessagePacket); break; case PacketType.Error: ErrorPacket errorPacket = new ErrorPacket(stream); errorPacket.Receive(); _context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(errorPacket.ErrorMessage, errorPacket.ErrorType)), null); break; case PacketType.UserConnect: UserConnectPacket userConnectPacket = new UserConnectPacket(stream); userConnectPacket.Receive(); lock (_users) { _users[userConnectPacket.UserLogin] = userConnectPacket.UserInfo; } _context.Post(p => UserConnected?.Invoke(this, new UserConnectedEventHandlerArgs(userConnectPacket.UserLogin, userConnectPacket.UserInfo)), null); break; case PacketType.UserDisconnect: UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream); userDisconnectPacket.Receive(); lock (_users) { _users.Remove(userDisconnectPacket.UserLogin); } _context.Post(p => UserDisconnected?.Invoke(this, new UserDisconnectedEventHandlerArgs(userDisconnectPacket.UserLogin)), null); break; case PacketType.CreateNewRoom: CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream); createNewRoomPacket.Receive(); lock (_rooms) { _rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room); } _context.Post(p => NewRoomCreated?.Invoke(this, new NewRoomCreatedEventHandlerArgs(createNewRoomPacket.Room)), null); break; case PacketType.AddUserToRoom: AddUsersToRoomPacket addUsersToRoomPacket = new AddUsersToRoomPacket(stream); addUsersToRoomPacket.Receive(); lock (_rooms) { foreach (string user in addUsersToRoomPacket.Users) { _rooms[addUsersToRoomPacket.RoomId].Members.Add(user); } } _context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null); break; case PacketType.RemoveUserFromRoom: RemoveUserFromRoomPacket removeUserFromRoomPacket = new RemoveUserFromRoomPacket(stream); removeUserFromRoomPacket.Receive(); lock (_rooms) { Room room; if (_rooms.TryGetValue(removeUserFromRoomPacket.RoomId, out room)) { room.Members.Remove(removeUserFromRoomPacket.User); } } _context.Post(p => RoomsUpdated?.Invoke(this, new RoomsUpdatedEventHandlerArgs()), null); break; } } } } catch (Exception) { _server.Close(); _server.Client.Dispose(); } }
private void Listener(TcpClient tcpClient) { try { using (Stream stream = tcpClient.GetStream()) { while (true) { BinaryReader streamReader = new BinaryReader(stream); PacketType packetType = (PacketType)streamReader.ReadInt32(); switch (packetType) { case PacketType.Registry: RegistryPacket registryPacket = new RegistryPacket(stream); registryPacket.Receive(); RegistryNewUser(tcpClient, registryPacket); break; case PacketType.Login: LoginPacket loginPacket = new LoginPacket(stream); loginPacket.Receive(); if (!LoginUser(tcpClient, loginPacket)) { return; } break; case PacketType.SimpleMessage: SimpleMessagePacket simpleMessagePacket = new SimpleMessagePacket(stream); simpleMessagePacket.Receive(); lock (_connectedUsers) { foreach (TcpClient client in _connectedUsers.Values) { simpleMessagePacket.Send(client.GetStream()); } } break; case PacketType.Disconnect: lock (_connectedUsers) { var item = _connectedUsers.First(u => u.Value == tcpClient); _connectedUsers.Remove(item.Key); } return; case PacketType.UserDisconnect: UserDisconnectPacket userDisconnectPacket = new UserDisconnectPacket(stream); userDisconnectPacket.Receive(); lock (_connectedUsers) { foreach (TcpClient client in _connectedUsers.Values) { userDisconnectPacket.Send(client.GetStream()); } } lock (_connectedUsers) { _connectedUsers.Remove(userDisconnectPacket.UserLogin); _context.Send(p => ClientDisconnected?.Invoke(this, new DisconnectedEventHandlerArgs(tcpClient, userDisconnectPacket.UserLogin)), null); } return; case PacketType.CreateNewRoom: lock (_rooms) { CreateNewRoomPacket createNewRoomPacket = new CreateNewRoomPacket(stream); createNewRoomPacket.Receive(); _rooms.Add(createNewRoomPacket.Room.Id, createNewRoomPacket.Room); lock (_connectedUsers) { foreach (var connectedUser in _connectedUsers.Where(cu => createNewRoomPacket.Room.Members.Contains(cu.Key))) { createNewRoomPacket.Send(connectedUser.Value.GetStream()); } } } break; case PacketType.CloseRoom: CloseRoomPacket closeRoomPacket = new CloseRoomPacket(stream); closeRoomPacket.Receive(); lock (_rooms) { Room room; if (_rooms.TryGetValue(closeRoomPacket.RoomId, out room)) { lock (_connectedUsers) { foreach (TcpClient client in _connectedUsers.Where(u => room.Members.Contains(u.Key)).Select(u => u.Value)) { new RemoveUserFromRoomPacket(client.GetStream(), closeRoomPacket.RoomId, closeRoomPacket.User).Send(); } } } } break; case PacketType.UpdateUser: UpdateUserPacket updateUserPacket = new UpdateUserPacket(stream); updateUserPacket.Receive(); UserManager.Instance.Update(updateUserPacket.Login, updateUserPacket.UserInfoWithPrivateInfo); break; } } } } catch (Exception ex) { _context.Post(p => ErrorOccurred?.Invoke(this, new ErrorOccurredEventHandlerArgs(ex.Message, ErrorType.ServerListener)), null); } }