public static bool ManageProfileImage(
ProfileImage image,
MessagingCallback callback,
object state)
{
bool flag = !string.IsNullOrEmpty(image.TypeName);
string strProfileImageUrl = null;
if (flag)
{
strProfileImageUrl = CreateOperationUri(image.TypeName);
flag = strProfileImageUrl != null;
}
if (flag)
{
flag = image.Image == null ? image.ResourceId != null && MessagingService.Instance.ManageProfileImage(strProfileImageUrl, image.ResourceId, callback, state) : MessagingService.Instance.ManageProfileImage(strProfileImageUrl, image.Image, callback, state);
}
if (flag)
{
if (image.Type == ProfileImageType.Background)
{
SQMLog.Log(SQMDataId.SocialEditBackground, 1);
}
else if (image.Type == ProfileImageType.Tile)
{
SQMLog.Log(SQMDataId.SocialEditTile, 1);
}
}
return(flag);
}
private void SendMessage(PeerId id, PeerMessage message, MessagingCallback callback)
{
try
{
id.MessageSentCallback = callback;
id.CurrentlySendingMessage = message;
RateLimiterGroup limiter = id.TorrentManager.UploadLimiter;
if (message is PieceMessage)
{
PeerIO.EnqueueSendMessage(id.Connection, id.Encryptor, message, limiter, id.Monitor, id.TorrentManager.Monitor, endSendMessageCallback, id);
ClientEngine.BufferManager.FreeBuffer(ref ((PieceMessage)message).Data);
id.IsRequestingPiecesCount--;
}
else
{
PeerIO.EnqueueSendMessage(id.Connection, id.Encryptor, message, null, id.Monitor, id.TorrentManager.Monitor, endSendMessageCallback, id);
}
}
catch (Exception ex)
{
CleanupSocket(id, ex.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
public ConnectionManager(ClientEngine engine)
{
this.engine = engine;
this.endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption);
this.endSendMessageCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndSendMessage(a, b, c));
this.endCreateConnectionCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndCreateConnection(a, b, c));
this.incomingConnectionAcceptedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => IncomingConnectionAccepted(a, b, c));
this.handshakeSentCallback = PeerHandshakeSent;
this.peerHandshakeReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => PeerHandshakeReceived(a, b, c));
this.messageSentCallback = PeerMessageSent;
this.messageReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => MessageReceived(a, b, c));
this.pendingConnects = new List <AsyncConnectState>();
}
public ConnectionManager(ClientEngine engine)
{
_engine = engine;
_endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption);
_endSendMessageCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndSendMessage(a, b, c));
_endCreateConnectionCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndCreateConnection(a, b, c));
IncomingConnectionAcceptedCallback =
(a, b, c) => ClientEngine.MainLoop.Queue(() => IncomingConnectionAccepted(a, b, c));
_handshakeSentCallback = PeerHandshakeSent;
_peerHandshakeReceivedCallback =
(a, b, c) => ClientEngine.MainLoop.Queue(() => PeerHandshakeReceived(a, b, c));
_messageSentCallback = PeerMessageSent;
MessageReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => MessageReceived(a, b, c));
_pendingConnects = new List<AsyncConnectState>();
}
public static bool ManageProfile(
string fieldName,
string fieldValue,
MessagingCallback callback,
object state)
{
bool flag = !string.IsNullOrEmpty(fieldName);
string strProfileUrl = null;
if (flag)
{
strProfileUrl = CreateOperationUri(fieldName);
flag = strProfileUrl != null;
}
if (flag)
{
flag = MessagingService.Instance.ManageProfile(strProfileUrl, fieldValue, callback, state);
}
return(flag);
}
private void SendMessage(PeerId id, PeerMessage message, MessagingCallback callback)
{
try
{
id.MessageSentCallback = callback;
id.CurrentlySendingMessage = message;
RateLimiterGroup limiter = id.TorrentManager.UploadLimiter;
if (message is PieceMessage)
{
PeerIO.EnqueueSendMessage (id.Connection, id.Encryptor, message, limiter, id.Monitor, id.TorrentManager.Monitor, endSendMessageCallback, id);
ClientEngine.BufferManager.FreeBuffer(ref ((PieceMessage)message).Data);
id.IsRequestingPiecesCount--;
}
else
PeerIO.EnqueueSendMessage (id.Connection, id.Encryptor, message, null, id.Monitor, id.TorrentManager.Monitor, endSendMessageCallback, id);
}
catch (Exception ex)
{
CleanupSocket(id, ex.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
public ConnectionManager(ClientEngine engine)
{
this.engine = engine;
this.endCheckEncryptionCallback = delegate(IAsyncResult result) { ClientEngine.MainLoop.Queue(delegate { EndCheckEncryption(result); }); };
this.endSendMessageCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { EndSendMessage(s, c, o); }); };
this.endCreateConnectionCallback = delegate(bool succeeded, object state) { ClientEngine.MainLoop.Queue(delegate { EndCreateConnection(succeeded, state); }); };
this.incomingConnectionAcceptedCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { IncomingConnectionAccepted(s, c, o); }); };
this.bitfieldSentCallback = new MessagingCallback(PeerBitfieldSent);
this.handshakeSentCallback = new MessagingCallback(this.PeerHandshakeSent);
this.handshakeReceievedCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { PeerHandshakeReceived(s, c, o); }); };
this.messageSentCallback = new MessagingCallback(this.PeerMessageSent);
this.torrents = new MonoTorrentCollection<TorrentManager>();
}
private void SendMessage(PeerId id, PeerMessage message, MessagingCallback callback)
{
bool cleanup = false;
try
{
if (id.Connection == null)
return;
ClientEngine.BufferManager.FreeBuffer(ref id.sendBuffer);
ClientEngine.BufferManager.GetBuffer(ref id.sendBuffer, message.ByteLength);
id.MessageSentCallback = callback;
id.CurrentlySendingMessage = message;
if (message is PieceMessage)
id.IsRequestingPiecesCount--;
id.BytesSent = 0;
id.BytesToSend = message.Encode(id.sendBuffer, 0);
id.Encryptor.Encrypt(id.sendBuffer.Array, id.sendBuffer.Offset, id.BytesToSend);
RateLimiter limiter = engine.Settings.GlobalMaxUploadSpeed > 0 ? engine.uploadLimiter : null;
limiter = limiter ?? (id.TorrentManager.Settings.MaxUploadSpeed > 0 ? id.TorrentManager.uploadLimiter : null);
NetworkIO.EnqueueSend(id.Connection, id.sendBuffer, id.BytesSent, id.BytesToSend, endSendMessageCallback, id, limiter, id.TorrentManager.Monitor, id.Monitor);
}
catch (Exception)
{
Logger.Log(id.Connection, "ConnectionManager - Socket error sending message");
cleanup = true;
}
finally
{
if (cleanup)
CleanupSocket(id, "Couldn't SendMessage");
}
}
