private async Task <HaveMessage> SaveMessage(CreateMessageRequest message)
{
//var isBlock = await _context.BlockUsers.AnyAsync(x => (x.FromUserId == message.SenderId && x.ToUserId == message.ReceiverId) || (x.FromUserId == message.ReceiverId && x.ToUserId == message.SenderId));
//if (isBlock)
//{
// return null;
//}
var newMessage = new HaveMessage()
{
SenderId = message.SenderId,
ReceiverId = message.ReceiverId,
Content = message.Content,
SentAt = DateTime.Now
};
try
{
_context.HaveMessages.Add(newMessage);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
return(newMessage);
}
private void Start()
{
MessageEvent += new HaveMessage(ShowMessages); //将委托绑定到事件上
GetComponentsRT();
identityData.SetActive(false);
remind.enabled = false;
}
protected virtual void HandleHave(HaveMessage have, PeerState peer)
{
if (have.PieceIndex < peer.Bitfield.Length)
{
peer.Bitfield[have.PieceIndex] = true;
}
}
public MessageResponse(HaveMessage message)
{
Id = message.Id;
SenderId = message.SenderId;
ReceiverId = message.ReceiverId;
Content = message.Content;
SentAt = message.SentAt;
}
public MessageResponse(HaveMessage message, IStorageService storageService)
{
Id = message.Id;
SenderId = message.SenderId;
ReceiverId = message.ReceiverId;
Content = message.Content;
SentAt = message.SentAt;
MessageType = message.MessageType;
SetImagePaths(storageService, message.FilePath);
}
public override bool Equals(object obj)
{
HaveMessage msg = obj as HaveMessage;
if (msg == null)
{
return(false);
}
return(this.pieceIndex == msg.pieceIndex);
}
void peer_HaveMessageReceived(object sender, HaveMessage e)
{
ShowMessage("{0}:Received {1}", sender, e);
Peer peer = (Peer)sender;
bool isInterested = _blockManager.ReceiveHave(e.Index);
if (isInterested && !peer.AmInterested)
{
peer.SendInterestedMessageAsync();
}
}
private async Task <HaveMessage> SaveMessage(CreateMessageRequest message)
{
//var isBlock = await _context.BlockUsers.AnyAsync(x => (x.FromUserId == message.SenderId && x.ToUserId == message.ReceiverId) || (x.FromUserId == message.ReceiverId && x.ToUserId == message.SenderId));
//if (isBlock)
//{
// return null;
//}
var newMessage = new HaveMessage()
{
SenderId = message.SenderId,
ReceiverId = message.ReceiverId,
Content = message.Content,
SentAt = DateTime.Now,
MessageType = "text"
};
string result = "";
List <string> fileNames = new List <string>();
var res = new List <string>();
if (message.Files != null && message.Files.Count > 0)
{
newMessage.MessageType = "image";
foreach (var item in message.Files)
{
string s = await _storageService.SaveFile(item);
res.Add(_storageService.GetFileUrl(s));
fileNames.Add(s);
}
result = String.Join(",", fileNames.ToArray());
}
newMessage.FilePath = result;
try
{
_context.HaveMessages.Add(newMessage);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
newMessage.FilePaths = res;
return(newMessage);
}
protected virtual void HandleHaveMessage (PeerId id, HaveMessage message)
{
id.HaveMessageEstimatedDownloadedBytes += Manager.Torrent.PieceLength;
// First set the peers bitfield to true for that piece
id.BitField[message.PieceIndex] = true;
// Fastcheck to see if a peer is a seeder or not
id.Peer.IsSeeder = id.BitField.AllTrue;
// We can do a fast check to see if the peer is interesting or not when we receive a Have Message.
// If the peer just received a piece we don't have, he's interesting. Otherwise his state is unchanged
if (!Manager.Bitfield[message.PieceIndex])
SetAmInterestedStatus (id, true);
}
public void Choke()
{
PeerId other = rig.CreatePeer(true);
// More slots than peers
for (int i = 0; i < 25; i++)
{
unchoker.UnchokeReview();
Assert.AreEqual(unchoker.MaxAdvertised, peer.QueueLength, "#1." + i);
HaveMessage h = (HaveMessage)peer.Dequeue();
Assert.AreEqual(i, h.PieceIndex, "#2." + i);
unchoker.ReceivedHave(peer, h.PieceIndex);
unchoker.ReceivedHave(other, h.PieceIndex);
}
}
public void HaveMessage_TryDecode()
{
HaveMessage message;
int offset = 0;
bool isIncomplete;
byte[] data = "0000000504000000AA".ToByteArray();
if (HaveMessage.TryDecode(data, ref offset, data.Length, out message, out isIncomplete))
{
Assert.AreEqual(9, message.Length);
Assert.AreEqual(170, message.PieceIndex);
Assert.AreEqual(false, isIncomplete);
Assert.AreEqual(data.Length, offset);
CollectionAssert.AreEqual(data, message.Encode());
}
else
{
Assert.Fail();
}
}
/// <summary>
/// Processes the received message.
/// </summary>
/// <param name="message">The message.</param>
private void ProcessRecievedMessage(HaveMessage message)
{
message.CannotBeNull();
if (this.HandshakeState == HandshakeState.SendAndReceived)
{
if (message.PieceIndex >= 0 &&
message.PieceIndex < this.pieceManager.PieceCount)
{
this.BitField[message.PieceIndex] = true;
// notify downloading thread
this.EnqueueDownloadMessage(message);
}
else
{
this.OnCommunicationErrorOccurred(this, new PeerCommunicationErrorEventArgs("Invalid have message.", false));
}
}
else
{
this.OnCommunicationErrorOccurred(this, new PeerCommunicationErrorEventArgs("Invalid message sequence.", true));
}
}
protected override void HandleHaveMessage(PeerId id, HaveMessage message)
{
base.HandleHaveMessage(id, message);
unchoker.ReceivedHave(id, message.PieceIndex);
}
public void OnMessageReceived(IMessageReceivedContext context)
{
// Read message
CommonPeerMessage message = MessageHandler.ReadMessage(context.Metainfo, context.Reader, context.MessageLength, (byte)context.MessageId);
if (message == null)
{
// Something went wrong
context.Peer.Disconnect();
return;
}
var peer = context.Peer;
// Process message
switch (message.ID)
{
case ChokeMessage.MessageID:
SetChokedByPeer(peer, true);
break;
case UnchokeMessage.MessageID:
SetChokedByPeer(peer, false);
break;
case InterestedMessage.MessageID:
SetPeerInterested(peer, true);
UnchokePeer(peer);
break;
case NotInterestedMessage.MessageID:
SetPeerInterested(peer, false);
break;
case HaveMessage.MessageId:
{
HaveMessage haveMessage = message as HaveMessage;
SetPeerBitfield(context, peer, haveMessage.Piece.Index, true);
break;
}
case BitfieldMessage.MessageId:
{
BitfieldMessage bitfieldMessage = message as BitfieldMessage;
SetPeerBitfield(peer, bitfieldMessage.Bitfield);
if (IsBitfieldInteresting(context, bitfieldMessage.Bitfield))
{
peer.IsInterestedInRemotePeer = true;
peer.SendMessage(new InterestedMessage());
}
break;
}
case RequestMessage.MessageID:
{
RequestMessage requestMessage = message as RequestMessage;
SetBlockRequestedByPeer(peer, requestMessage.Block);
break;
}
case CancelMessage.MessageID:
{
CancelMessage cancelMessage = message as CancelMessage;
SetBlockCancelledByPeer(peer, cancelMessage.Block);
break;
}
case PieceMessage.MessageId:
{
PieceMessage pieceMessage = message as PieceMessage;
BlockReceived(context, peer, pieceMessage.Block);
break;
}
}
}
protected override void HandleHaveMessage(PeerId id, HaveMessage message)
{
base.HandleHaveMessage(id, message);
_unchoker.ReceivedHave(id, message.PieceIndex);
}
protected override void HandleHaveMessage(PeerId id, HaveMessage message)
{
// Nothing
}
protected virtual void HandleHaveMessage(PeerId id, HaveMessage message)
{
id.HaveMessagesReceived++;
// First set the peers bitfield to true for that piece
id.BitField[message.PieceIndex] = true;
// Fastcheck to see if a peer is a seeder or not
id.Peer.IsSeeder = id.BitField.AllTrue;
// We can do a fast check to see if the peer is interesting or not when we receive a Have Message.
// If the peer just received a piece we don't have, he's interesting. Otherwise his state is unchanged
if (!_manager.Bitfield[message.PieceIndex])
SetAmInterestedStatus(id, true);
}
public void HaveEncoding()
{
int length = new HaveMessage(150).Encode(buffer, offset);
Assert.AreEqual("00-00-00-05-04-00-00-00-96", BitConverter.ToString(buffer, offset, length));
}
/// <summary>
/// Send have message asynchronously
/// </summary>
/// <param name="index">the index of piece</param>
public void SendHaveMessageAsync(int index)
{
HaveMessage message = new HaveMessage(index);
SendMessageAsync(message);
}
