private void HandlePeerEvent(PeerEventData peerEventData)
{
if (peerEventData.EventStatus == PeerEventStatus.Partial)
{
return;
}
if (peerEventData.EventType == PeerEventType.Choke)
{
PeerChocking = true;
}
if (peerEventData.EventType == PeerEventType.Unchoke)
{
PeerChocking = false;
}
if (peerEventData.EventType == PeerEventType.Piece)
{
PieceRequestComplete();
}
if (peerEventData.EventType == PeerEventType.Bitfield && !ParseBitfield(peerEventData))
{
HandleDisconnect("Invalid bitfield sent");
return;
}
var eventArgs = new PeerEventArgs(peerEventData);
PeerEventHandler(this, eventArgs);
}
private void OnPeerError(object sender, PeerEventArgs args)
{
PeerSocket peer = sender as PeerSocket;
UserInfo userInfo = peer.Info as UserInfo;
Debug.Log("Peer ({0}) Error: {1}", userInfo.Name, args.Message);
}
private void HandleDisconnect(string exceptionMessage = null)
{
var peerEventData = new PeerEventData(PeerEventStatus.Error, PeerEventType.ConnectionClosed, 0, null, exceptionMessage);
var eventArgs = new PeerEventArgs(peerEventData);
PeerEventHandler(this, eventArgs);
}
private void SdkWrapper_PeerUpdated(object sender, PeerEventArgs e)
{
if (peerJidTyping?.Count > 0)
{
if (peerJidTyping.Contains(e.Peer.Jid))
{
UpdateUsersTyping(peerJidTyping);
}
}
}
private void OnPeerDisconnect(object sender, PeerEventArgs args)
{
PeerSocket peer = sender as PeerSocket;
Gtk.Application.Invoke(delegate {
if (peer.Info != null)
{
RemoveUser((UserInfo)peer.Info);
}
});
}
private void ChatOnMemberConnected(object sender, PeerEventArgs e)
{
var messageHandler = new PascalMessageHandler();
messageHandler.MessageReceived += (o, ea) => NotifyMessageReceived(e.Peer, ea);
_sessions.Add(e.Peer.EndPoint, new Tuple <Peer, PascalMessageHandler>(e.Peer, messageHandler));
_comunicationManager.Receive(4, e.Peer.EndPoint);
Display(e.Peer.EndPoint + " has joined");
}
/// <summary>Just connected to remote service. Send handshake packet.</summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
void OnConnectionStateChanged(object sender, PeerEventArgs e)
{
var evnt = ConnectionStateChanged;
if (e.ConnectionState == ConnectionState.Connected) {
_peer.Send(new HandshakePacket(Guid.Empty));
return; // Do not raise ConnectionStateChanged when connected. (Wait for HandshakePacket)
}
// Failed to connect/Disconnected
if (evnt != null) evnt(this, new ConnectionEventArgs(null, e.ConnectionState));
}
private void OnPeerError(object sender, PeerEventArgs args)
{
PeerSocket peer = sender as PeerSocket;
UserInfo userInfo = peer.Info as UserInfo;
Debug.Log("Peer ({0}) Error: {1}", userInfo.Name, args.Message);
#if false
Gtk.Application.Invoke(delegate {
Glue.Dialogs.MessageError(userInfo.Name + " Error", args.Message);
});
Gtk.Application.Quit();
Environment.Exit(0);
#endif
}
private void OnPeerEvent(object sender, PeerEventArgs eventArgs)
{
var eventData = eventArgs.EventData;
var senderPeer = (SocketPeer)sender;
if (!Peers.Contains(senderPeer))
{
return;
}
if (eventData.EventType == PeerEventType.ConnectionClosed)
{
DisconnectPeer(senderPeer);
}
}
private async void ChatOnMemberConnected(object sender, PeerEventArgs e)
{
var sr = new PascalStreamReader(e.Peer.Stream);
_sessions.Add(e.Peer.EndPoint, new Tuple <Peer, PascalStreamReader>(e.Peer, sr));
Display(e.Peer.EndPoint + " has joined");
byte[] bytes;
while (true)
{
bytes = await sr.ReadBytesAsync();
Display(e.Peer.EndPoint + " say:");
Display(" " + GetString(bytes));
}
}
private void PeerDisconnect(object sender, PeerEventArgs e)
{
if (OnPeerDisconnected != null)
{
OnPeerDisconnected(null, e);
}
ConnectedPeers.Remove(e.Peer);
if (_debug)
{
Debug.Print("Peer disconnected from: {0} with reason: {1}", e.Peer.RemoteEndPoint,
((PeerDisconnectedEventArgs)e).DisconnectReason);
}
}
private void NewPeer_peerStatusChange(object sender, PeerEventArgs e)
{
Peer changedPeer = e.Peer;
//delete inactive peers
bool isPeerActive = changedPeer.IsPeerActive;
if (!isPeerActive)
{
//delete from list
knownPeers.Remove(changedPeer);
}
//tell others a peer has been deleted
PeerChange?.Invoke(this, new PeerChangeEventArgs(knownPeers));
}
// ============================================
// PRIVATE (Methods) Event Handlers
// ============================================
private void OnReceived(object sender, PeerEventArgs args)
{
PeerSocket peer = sender as PeerSocket;
// Get Response String and Check if is Valid Xml
string xml = peer.GetResponseString();
if (xml == null)
{
return;
}
// Remove Response Message
peer.ResetResponse();
// Get Xml Commands
xml = xml.Trim();
ArrayList xmlCmds = new ArrayList();
lock (peer.Response) {
int splitPos = 0;
while ((splitPos = xml.IndexOf("><")) >= 0)
{
// Add Xml Command To Cmds
string cmd = xml.Substring(0, splitPos + 1);
xmlCmds.Add(cmd);
// Remove Splitted Part
xml = xml.Remove(0, splitPos + 1);
}
if (XmlRequest.IsEndedXml(xml) == false)
{
peer.Response.Insert(0, xml);
}
else
{
xmlCmds.Add(xml);
}
}
// Start New Command Parse Thread
new CmdParse(peer, xmlCmds);
}
private void OnPeerEvent(object sender, PeerEventArgs eventArgs)
{
PeerEventHandlerEcho?.Invoke(sender, eventArgs);
var eventData = eventArgs.EventData;
var senderPeer = (SocketPeer)sender;
if (eventData.EventType == PeerEventType.Choke || eventData.EventType == PeerEventType.ConnectionClosed)
{
FreeUpPiece(senderPeer);
}
if (eventData.EventType == PeerEventType.Piece)
{
if (eventData.Length < 9)
{
return; //Payload length must be at least 9. Discarded otherwise.
}
var payload = eventData.Payload;
var pieceIndex = ByteConverter.BytesToUint(payload.Take(4).ToArray());
var blockOffset = ByteConverter.BytesToUint(payload.Skip(4).Take(4).ToArray());
var blockData = payload.Skip(8).ToArray();
if (pieceIndex >= Pieces.Count)
{
return; //Got sent a piece with index that does not exist. Discarded.
}
//TODO: CASTING TO INT HERE IS BAD. FIX.
lock (_pieceLock)
{
if (!_pieces[(int)pieceIndex].TryAddBlock(blockData, blockOffset))
{
return; //Add failed. Discarded.
}
_pendingPieces.Remove(_pieces[(int)pieceIndex]);
}
}
}
// ============================================
// PRIVATE (Methods) Event Handlers
// ============================================
private void OnPeerDisconnect(object sender, PeerEventArgs args)
{
Abort();
}
/// <summary>New peer connected to service.</summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">event args.</param>
void OnPeerConnectionAccepted(object sender, PeerEventArgs e)
{
e.Peer.PacketReceived += OnPacketReceived;
e.Peer.ConnectionStateChanged += OnPeerConnectionStateChanged;
}
/// <summary>Client disconnected from service.</summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
void OnPeerConnectionStateChanged(object sender, PeerEventArgs e)
{
if (e.ConnectionState != ConnectionState.Disconnected) return;
if (!_users.IsPeerStored(e.Peer)) return;
e.Peer.PacketReceived -= OnPacketReceived;
e.Peer.ConnectionStateChanged -= OnPeerConnectionStateChanged;
var evnt = UserConnectionStateChanged;
if (evnt != null) evnt(this, new ConnectionEventArgs(_users.GetUser(e.Peer), ConnectionState.Disconnected));
}
internal void OnPeerAvatarUpdated(object sender, PeerEventArgs args)
{
PeerAvatarUpdated.Raise(sender, args);
}
/// <summary>Packet received from client.</summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
void OnPacketReceived(object sender, PeerEventArgs e)
{
var peer = e.Peer;
var packet = e.Packet;
if (e.Packet is HandshakePacket) {
var session = ((HandshakePacket)packet).Session;
if (session == Guid.Empty) session = Guid.NewGuid();
var user = new User(session);
peer.Send(new HandshakePacket(session));
// TODO Move it to another place
lock (_entities) {
foreach (var entity in _entities.Entities) {
var id = _entities.GetId(entity);
e.Peer.Send(new AddEntityPacket(id, entity));
}
}
//
lock (_users) { _users.Map(user, peer); }
var evnt = UserConnectionStateChanged;
if (evnt != null) evnt(this, new ConnectionEventArgs(user, ConnectionState.Connected));
} else {
var user = _users.GetUser(peer);
var evnt = PacketReceived;
if (evnt != null) evnt(this, new PacketEventArgs(packet, user));
}
}
internal void OnContactAdded(object sender, PeerEventArgs args)
{
PeerAdded.Raise(sender, args);
}
internal void OnContactInfoChanged(object sender, PeerEventArgs args)
{
PeerInfoChanged.Raise(sender, args);
}
private void PeerDisconnect(object sender, PeerEventArgs e)
{
if (OnPeerDisconnected != null)
OnPeerDisconnected(null, e);
ConnectedPeers.Remove(e.Peer);
if (_debug)
Debug.Print("Peer disconnected from: {0} with reason: {1}", e.Peer.RemoteEndPoint,
((PeerDisconnectedEventArgs) e).DisconnectReason);
}
/// <summary>New packet has been received.</summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
void OnPacketReceived(object sender, PeerEventArgs e)
{
// TODO Refactor this shit.
if (e.Packet is HandshakePacket) {
var evnt = ConnectionStateChanged;
var packet = (HandshakePacket)e.Packet;
if (evnt != null) evnt(this, new ConnectionEventArgs(new User(packet.Session), ConnectionState.Connected));
} else if (e.Packet is AddEntityPacket) {
var evnt = EntityStateChanged;
var packet = (AddEntityPacket)e.Packet;
_entities.Add(packet.EntityId, packet.Entity);
if (evnt != null) evnt(this, new EntityEventArgs(packet.Entity, EntityState.Added));
} else if (e.Packet is RemoveEntityPacket) {
var evnt = EntityStateChanged;
var packet = (RemoveEntityPacket)e.Packet;
var entity = _entities[packet.EntityId];
_entities.Remove(packet.EntityId);
if (evnt != null) evnt(this, new EntityEventArgs(entity, EntityState.Removed));
} else if (e.Packet is SyncEntityPacket) {
var evnt = EntityStateChanged;
var packet = (SyncEntityPacket)e.Packet;
var entity = _entities[packet.EntityId];
packet.Diff.ApplyChanges(entity);
if (evnt != null) evnt(this, new EntityEventArgs(entity, EntityState.Modified));
} else {
var evnt = PacketReceived;
if (evnt != null) evnt(this, new PacketEventArgs(e.Packet));
}
}
private static void OnPeerEvent(object sender, PeerEventArgs peerEventArgs)
{
}
