sochix/TLSharp
1
0
Fork 0
mirror of https://github.com/sochix/TLSharp.git synced 2025-12-06 08:02:00 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #903 from CheshireCaat/pr-branch

Browse source 
Improvements for async methods
This commit is contained in:
Andres G. Aragoneses 2020-01-28 15:12:26 +08:00 committed by GitHub
parent 1ccafe22a3 c5a2c816fc
commit c031fa4f6d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 198 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
TLSharp.Core/Auth/Authenticator.cs
View file

@ -1,37 +1,45 @@
using System.Threading.Tasks;
using System.Threading;
using System.Threading.Tasks;
using TLSharp.Core.Network;
namespace TLSharp.Core.Auth
{
public static class Authenticator
{
public static async Task<Step3_Response> DoAuthentication(TcpTransport transport)
public static async Task<Step3_Response> DoAuthentication(TcpTransport transport, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
var sender = new MtProtoPlainSender(transport);
var step1 = new Step1_PQRequest();
await sender.Send(step1.ToBytes());
var step1Response = step1.FromBytes(await sender.Receive());
await sender.Send(step1.ToBytes(), token).ConfigureAwait(false);
var step1Response = step1.FromBytes(await sender.Receive(token)
.ConfigureAwait(false));
var step2 = new Step2_DHExchange();
await sender.Send(step2.ToBytes(
step1Response.Nonce,
step1Response.ServerNonce,
step1Response.Fingerprints,
step1Response.Pq));
step1Response.Nonce,
step1Response.ServerNonce,
step1Response.Fingerprints,
step1Response.Pq), token)
.ConfigureAwait(false);
var step2Response = step2.FromBytes(await sender.Receive());
var step2Response = step2.FromBytes(await sender.Receive(token)
.ConfigureAwait(false));
var step3 = new Step3_CompleteDHExchange();
await sender.Send(step3.ToBytes(
step2Response.Nonce,
step2Response.ServerNonce,
step2Response.NewNonce,
step2Response.EncryptedAnswer));
step2Response.Nonce,
step2Response.ServerNonce,
step2Response.NewNonce,
step2Response.EncryptedAnswer), token)
.ConfigureAwait(false);
var step3Response = step3.FromBytes(await sender.Receive());
var step3Response = step3.FromBytes(await sender.Receive(token)
.ConfigureAwait(false));
return step3Response;
}
}
}
}

13
TLSharp.Core/Network/MtProtoPlainSender.cs
View file

@ -1,5 +1,6 @@
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
namespace TLSharp.Core.Network
@ -17,8 +18,10 @@ namespace TLSharp.Core.Network
random = new Random();
}
public async Task Send(byte[] data)
public async Task Send(byte[] data, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
using (var memoryStream = new MemoryStream())
{
using (var binaryWriter = new BinaryWriter(memoryStream))
@ -30,14 +33,16 @@ namespace TLSharp.Core.Network
byte[] packet = memoryStream.ToArray();
await _transport.Send(packet);
await _transport.Send(packet, token).ConfigureAwait(false);
}
}
}
public async Task<byte[]> Receive()
public async Task<byte[]> Receive(CancellationToken token = default(CancellationToken))
{
var result = await _transport.Receive();
token.ThrowIfCancellationRequested();
var result = await _transport.Receive(token).ConfigureAwait(false);
using (var memoryStream = new MemoryStream(result.Body))
{

59
TLSharp.Core/Network/MtProtoSender.cs
View file

@ -7,6 +7,7 @@ using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Ionic.Zlib;
using TeleSharp.TL;
using TLSharp.Core.Exceptions;
using TLSharp.Core.MTProto;
using TLSharp.Core.MTProto.Crypto;
@ -36,8 +37,10 @@ namespace TLSharp.Core.Network
return confirmed ? _session.Sequence++ * 2 + 1 : _session.Sequence * 2;
}
public async Task Send(TeleSharp.TL.TLMethod request)
public async Task Send(TeleSharp.TL.TLMethod request, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
// TODO: refactor
if (needConfirmation.Any())
{
@ -46,7 +49,7 @@ namespace TLSharp.Core.Network
using (var writer = new BinaryWriter(memory))
{
ackRequest.SerializeBody(writer);
await Send(memory.ToArray(), ackRequest);
await Send(memory.ToArray(), ackRequest, token).ConfigureAwait(false);
needConfirmation.Clear();
}
}
@ -56,14 +59,16 @@ namespace TLSharp.Core.Network
using (var writer = new BinaryWriter(memory))
{
request.SerializeBody(writer);
await Send(memory.ToArray(), request);
await Send(memory.ToArray(), request, token).ConfigureAwait(false);
}
_session.Save();
}
public async Task Send(byte[] packet, TeleSharp.TL.TLMethod request)
public async Task Send(byte[] packet, TeleSharp.TL.TLMethod request, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
request.MessageId = _session.GetNewMessageId();
byte[] msgKey;
@ -92,7 +97,7 @@ namespace TLSharp.Core.Network
writer.Write(msgKey);
writer.Write(ciphertext);
await _transport.Send(ciphertextPacket.GetBuffer());
await _transport.Send(ciphertextPacket.GetBuffer(), token).ConfigureAwait(false);
}
}
}
@ -129,37 +134,43 @@ namespace TLSharp.Core.Network
return new Tuple<byte[], ulong, int>(message, remoteMessageId, remoteSequence);
}
public async Task<byte[]> Receive(TeleSharp.TL.TLMethod request)
public async Task<byte[]> Receive(TeleSharp.TL.TLMethod request, CancellationToken token = default(CancellationToken))
{
while (!request.ConfirmReceived)
{
var result = DecodeMessage((await _transport.Receive()).Body);
var result = DecodeMessage((await _transport.Receive(token).ConfigureAwait(false)).Body);
using (var messageStream = new MemoryStream(result.Item1, false))
using (var messageReader = new BinaryReader(messageStream))
{
processMessage(result.Item2, result.Item3, messageReader, request);
processMessage(result.Item2, result.Item3, messageReader, request, token);
}
token.ThrowIfCancellationRequested();
}
return null;
}
public async Task SendPingAsync()
public async Task SendPingAsync(CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
var pingRequest = new PingRequest();
using (var memory = new MemoryStream())
using (var writer = new BinaryWriter(memory))
{
pingRequest.SerializeBody(writer);
await Send(memory.ToArray(), pingRequest);
await Send(memory.ToArray(), pingRequest, token).ConfigureAwait(false);
}
await Receive(pingRequest);
await Receive(pingRequest, token).ConfigureAwait(false);
}
private bool processMessage(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request)
private bool processMessage(ulong messageId, int sequence, BinaryReader messageReader, TLMethod request, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
// TODO: check salt
// TODO: check sessionid
// TODO: check seqno
@ -173,7 +184,7 @@ namespace TLSharp.Core.Network
{
case 0x73f1f8dc: // container
//logger.debug("MSG container");
return HandleContainer(messageId, sequence, messageReader, request);
return HandleContainer(messageId, sequence, messageReader, request, token);
case 0x7abe77ec: // ping
//logger.debug("MSG ping");
return HandlePing(messageId, sequence, messageReader);
@ -191,7 +202,7 @@ namespace TLSharp.Core.Network
return HandleMsgsAck(messageId, sequence, messageReader);
case 0xedab447b: // bad_server_salt
//logger.debug("MSG bad_server_salt");
return HandleBadServerSalt(messageId, sequence, messageReader, request);
return HandleBadServerSalt(messageId, sequence, messageReader, request, token);
case 0xa7eff811: // bad_msg_notification
//logger.debug("MSG bad_msg_notification");
return HandleBadMsgNotification(messageId, sequence, messageReader);
@ -203,7 +214,7 @@ namespace TLSharp.Core.Network
return HandleRpcResult(messageId, sequence, messageReader, request);
case 0x3072cfa1: // gzip_packed
//logger.debug("MSG gzip_packed");
return HandleGzipPacked(messageId, sequence, messageReader, request);
return HandleGzipPacked(messageId, sequence, messageReader, request, token);
case 0xe317af7e:
case 0xd3f45784:
case 0x2b2fbd4e:
@ -235,14 +246,16 @@ namespace TLSharp.Core.Network
*/
}
private bool HandleGzipPacked(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request)
private bool HandleGzipPacked(ulong messageId, int sequence, BinaryReader messageReader, TLMethod request, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
uint code = messageReader.ReadUInt32();
byte[] packedData = GZipStream.UncompressBuffer(Serializers.Bytes.Read(messageReader));
using (MemoryStream packedStream = new MemoryStream(packedData, false))
using (BinaryReader compressedReader = new BinaryReader(packedStream))
{
processMessage(messageId, sequence, compressedReader, request);
processMessage(messageId, sequence, compressedReader, request, token);
}
return true;
@ -414,8 +427,10 @@ namespace TLSharp.Core.Network
return true;
}
private bool HandleBadServerSalt(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request)
private bool HandleBadServerSalt(ulong messageId, int sequence, BinaryReader messageReader, TLMethod request, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
uint code = messageReader.ReadUInt32();
ulong badMsgId = messageReader.ReadUInt64();
int badMsgSeqNo = messageReader.ReadInt32();
@ -427,7 +442,7 @@ namespace TLSharp.Core.Network
_session.Salt = newSalt;
//resend
Send(request);
Send(request, token);
/*
if(!runningRequests.ContainsKey(badMsgId)) {
logger.debug("bad server salt on unknown message");
@ -493,8 +508,10 @@ namespace TLSharp.Core.Network
return false;
}
private bool HandleContainer(ulong messageId, int sequence, BinaryReader messageReader, TeleSharp.TL.TLMethod request)
private bool HandleContainer(ulong messageId, int sequence, BinaryReader messageReader, TLMethod request, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
uint code = messageReader.ReadUInt32();
int size = messageReader.ReadInt32();
for (int i = 0; i < size; i++)
@ -505,7 +522,7 @@ namespace TLSharp.Core.Network
long beginPosition = messageReader.BaseStream.Position;
try
{
if (!processMessage(innerMessageId, sequence, messageReader, request))
if (!processMessage(innerMessageId, sequence, messageReader, request, token))
{
messageReader.BaseStream.Position = beginPosition + innerLength;
}

15
TLSharp.Core/Network/TcpTransport.cs
View file

@ -1,6 +1,7 @@
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
namespace TLSharp.Core.Network
@ -32,26 +33,26 @@ namespace TLSharp.Core.Network
}
}
public async Task Send(byte[] packet)
public async Task Send(byte[] packet, CancellationToken token = default(CancellationToken))
{
if (!_tcpClient.Connected)
throw new InvalidOperationException("Client not connected to server.");
var tcpMessage = new TcpMessage(sendCounter, packet);
await _stream.WriteAsync(tcpMessage.Encode(), 0, tcpMessage.Encode().Length);
await _stream.WriteAsync(tcpMessage.Encode(), 0, tcpMessage.Encode().Length, token).ConfigureAwait(false);
sendCounter++;
}
public async Task<TcpMessage> Receive()
public async Task<TcpMessage> Receive(CancellationToken token = default(CancellationToken))
{
var packetLengthBytes = new byte[4];
if (await _stream.ReadAsync(packetLengthBytes, 0, 4) != 4)
if (await _stream.ReadAsync(packetLengthBytes, 0, 4, token).ConfigureAwait(false) != 4)
throw new InvalidOperationException("Couldn't read the packet length");
int packetLength = BitConverter.ToInt32(packetLengthBytes, 0);
var seqBytes = new byte[4];
if (await _stream.ReadAsync(seqBytes, 0, 4) != 4)
if (await _stream.ReadAsync(seqBytes, 0, 4, token).ConfigureAwait(false) != 4)
throw new InvalidOperationException("Couldn't read the sequence");
int seq = BitConverter.ToInt32(seqBytes, 0);
@ -62,7 +63,7 @@ namespace TLSharp.Core.Network
do
{
var bodyByte = new byte[packetLength - 12];
var availableBytes = await _stream.ReadAsync(bodyByte, 0, neededToRead);
var availableBytes = await _stream.ReadAsync(bodyByte, 0, neededToRead, token).ConfigureAwait(false);
neededToRead -= availableBytes;
Buffer.BlockCopy(bodyByte, 0, body, readBytes, availableBytes);
readBytes += availableBytes;
@ -70,7 +71,7 @@ namespace TLSharp.Core.Network
while (readBytes != packetLength - 12);
var crcBytes = new byte[4];
if (await _stream.ReadAsync(crcBytes, 0, 4) != 4)
if (await _stream.ReadAsync(crcBytes, 0, 4, token).ConfigureAwait(false) != 4)
throw new InvalidOperationException("Couldn't read the crc");
int checksum = BitConverter.ToInt32(crcBytes, 0);

197
TLSharp.Core/TelegramClient.cs
View file

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using TeleSharp.TL;
using TeleSharp.TL.Account;
@ -55,11 +56,13 @@ namespace TLSharp.Core
_transport = new TcpTransport(_session.DataCenter.Address, _session.DataCenter.Port, _handler);
}
public async Task ConnectAsync(bool reconnect = false)
public async Task ConnectAsync(bool reconnect = false, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
if (_session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(_transport);
var result = await Authenticator.DoAuthentication(_transport, token).ConfigureAwait(false);
_session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset;
}
@ -78,14 +81,16 @@ namespace TLSharp.Core
SystemVersion = "Win 10.0"
};
var invokewithLayer = new TLRequestInvokeWithLayer() { Layer = 66, Query = request };
await _sender.Send(invokewithLayer);
await _sender.Receive(invokewithLayer);
await _sender.Send(invokewithLayer, token).ConfigureAwait(false);
await _sender.Receive(invokewithLayer, token).ConfigureAwait(false);
dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
}
private async Task ReconnectToDcAsync(int dcId)
private async Task ReconnectToDcAsync(int dcId, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
if (dcOptions == null || !dcOptions.Any())
throw new InvalidOperationException($"Can't reconnect. Establish initial connection first.");
@ -93,7 +98,7 @@ namespace TLSharp.Core
if (_session.TLUser != null)
{
TLRequestExportAuthorization exportAuthorization = new TLRequestExportAuthorization() { DcId = dcId };
exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization);
exported = await SendRequestAsync<TLExportedAuthorization>(exportAuthorization, token).ConfigureAwait(false);
}
var dc = dcOptions.First(d => d.Id == dcId);
@ -102,17 +107,17 @@ namespace TLSharp.Core
_transport = new TcpTransport(dc.IpAddress, dc.Port, _handler);
_session.DataCenter = dataCenter;
await ConnectAsync(true);
await ConnectAsync(true, token).ConfigureAwait(false);
if (_session.TLUser != null)
{
TLRequestImportAuthorization importAuthorization = new TLRequestImportAuthorization() { Id = exported.Id, Bytes = exported.Bytes };
var imported = await SendRequestAsync<TLAuthorization>(importAuthorization);
var imported = await SendRequestAsync<TLAuthorization>(importAuthorization, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)imported.User));
}
}
private async Task RequestWithDcMigration(TLMethod request)
private async Task RequestWithDcMigration(TLMethod request, CancellationToken token = default(CancellationToken))
{
if (_sender == null)
throw new InvalidOperationException("Not connected!");
@ -122,8 +127,8 @@ namespace TLSharp.Core
{
try
{
await _sender.Send(request);
await _sender.Receive(request);
await _sender.Send(request, token).ConfigureAwait(false);
await _sender.Receive(request, token).ConfigureAwait(false);
completed = true;
}
catch(DataCenterMigrationException e)
@ -134,7 +139,7 @@ namespace TLSharp.Core
throw new Exception($"Telegram server replied requesting a migration to DataCenter {e.DC} when this connection was already using this DataCenter", e);
}
await ReconnectToDcAsync(e.DC);
await ReconnectToDcAsync(e.DC, token).ConfigureAwait(false);
// prepare the request for another try
request.ConfirmReceived = false;
}
@ -146,31 +151,31 @@ namespace TLSharp.Core
return _session.TLUser != null;
}
public async Task<bool> IsPhoneRegisteredAsync(string phoneNumber)
public async Task<bool> IsPhoneRegisteredAsync(string phoneNumber, CancellationToken token = default(CancellationToken))
{
if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber));
var authCheckPhoneRequest = new TLRequestCheckPhone() { PhoneNumber = phoneNumber };
await RequestWithDcMigration(authCheckPhoneRequest);
await RequestWithDcMigration(authCheckPhoneRequest, token).ConfigureAwait(false);
return authCheckPhoneRequest.Response.PhoneRegistered;
}
public async Task<string> SendCodeRequestAsync(string phoneNumber)
public async Task<string> SendCodeRequestAsync(string phoneNumber, CancellationToken token = default(CancellationToken))
{
if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber));
var request = new TLRequestSendCode() { PhoneNumber = phoneNumber, ApiId = _apiId, ApiHash = _apiHash };
await RequestWithDcMigration(request);
await RequestWithDcMigration(request, token).ConfigureAwait(false);
return request.Response.PhoneCodeHash;
}
public async Task<TLUser> MakeAuthAsync(string phoneNumber, string phoneCodeHash, string code)
public async Task<TLUser> MakeAuthAsync(string phoneNumber, string phoneCodeHash, string code, CancellationToken token = default(CancellationToken))
{
if (String.IsNullOrWhiteSpace(phoneNumber))
throw new ArgumentNullException(nameof(phoneNumber));
@ -183,24 +188,26 @@ namespace TLSharp.Core
var request = new TLRequestSignIn() { PhoneNumber = phoneNumber, PhoneCodeHash = phoneCodeHash, PhoneCode = code };
await RequestWithDcMigration(request);
await RequestWithDcMigration(request, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)request.Response.User));
return ((TLUser)request.Response.User);
}
public async Task<TLPassword> GetPasswordSetting()
public async Task<TLPassword> GetPasswordSetting(CancellationToken token = default(CancellationToken))
{
var request = new TLRequestGetPassword();
await RequestWithDcMigration(request);
await RequestWithDcMigration(request, token).ConfigureAwait(false);
return ((TLPassword)request.Response);
}
public async Task<TLUser> MakeAuthWithPasswordAsync(TLPassword password, string password_str)
public async Task<TLUser> MakeAuthWithPasswordAsync(TLPassword password, string password_str, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
byte[] password_Bytes = Encoding.UTF8.GetBytes(password_str);
IEnumerable<byte> rv = password.CurrentSalt.Concat(password_Bytes).Concat(password.CurrentSalt);
@ -209,105 +216,114 @@ namespace TLSharp.Core
var request = new TLRequestCheckPassword() { PasswordHash = password_hash };
await RequestWithDcMigration(request);
await RequestWithDcMigration(request, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)request.Response.User));
return ((TLUser)request.Response.User);
}
public async Task<TLUser> SignUpAsync(string phoneNumber, string phoneCodeHash, string code, string firstName, string lastName)
public async Task<TLUser> SignUpAsync(string phoneNumber, string phoneCodeHash, string code, string firstName, string lastName, CancellationToken token = default(CancellationToken))
{
var request = new TLRequestSignUp() { PhoneNumber = phoneNumber, PhoneCode = code, PhoneCodeHash = phoneCodeHash, FirstName = firstName, LastName = lastName };
await RequestWithDcMigration(request);
await RequestWithDcMigration(request, token).ConfigureAwait(false);
OnUserAuthenticated(((TLUser)request.Response.User));
return ((TLUser)request.Response.User);
}
public async Task<T> SendRequestAsync<T>(TLMethod methodToExecute)
public async Task<T> SendRequestAsync<T>(TLMethod methodToExecute, CancellationToken token = default(CancellationToken))
{
await RequestWithDcMigration(methodToExecute);
await RequestWithDcMigration(methodToExecute, token).ConfigureAwait(false);
var result = methodToExecute.GetType().GetProperty("Response").GetValue(methodToExecute);
return (T)result;
}
private async Task<T> SendAuthenticatedRequestAsync<T> (TLMethod methodToExecute)
internal async Task<T> SendAuthenticatedRequestAsync<T> (TLMethod methodToExecute, CancellationToken token = default(CancellationToken))
{
if (!IsUserAuthorized())
throw new InvalidOperationException("Authorize user first!");
return await SendRequestAsync<T>(methodToExecute);
return await SendRequestAsync<T>(methodToExecute, token)
.ConfigureAwait(false);
}
public async Task<TLUser> UpdateUsernameAsync(string username)
public async Task<TLUser> UpdateUsernameAsync(string username, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestUpdateUsername { Username = username };
return await SendAuthenticatedRequestAsync<TLUser>(req);
return await SendAuthenticatedRequestAsync<TLUser>(req, token)
.ConfigureAwait(false);
}
public async Task<bool> CheckUsernameAsync(string username)
public async Task<bool> CheckUsernameAsync(string username, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestCheckUsername { Username = username };
return await SendAuthenticatedRequestAsync<bool>(req);
return await SendAuthenticatedRequestAsync<bool>(req, token)
.ConfigureAwait(false);
}
public async Task<TLImportedContacts> ImportContactsAsync(IReadOnlyList<TLInputPhoneContact> contacts)
public async Task<TLImportedContacts> ImportContactsAsync(IReadOnlyList<TLInputPhoneContact> contacts, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestImportContacts { Contacts = new TLVector<TLInputPhoneContact>(contacts)};
return await SendAuthenticatedRequestAsync<TLImportedContacts>(req);
return await SendAuthenticatedRequestAsync<TLImportedContacts>(req, token)
.ConfigureAwait(false);
}
public async Task<bool> DeleteContactsAsync(IReadOnlyList<TLAbsInputUser> users)
public async Task<bool> DeleteContactsAsync(IReadOnlyList<TLAbsInputUser> users, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestDeleteContacts {Id = new TLVector<TLAbsInputUser>(users)};
return await SendAuthenticatedRequestAsync<bool>(req);
return await SendAuthenticatedRequestAsync<bool>(req, token)
.ConfigureAwait(false);
}
public async Task<TLLink> DeleteContactAsync(TLAbsInputUser user)
public async Task<TLLink> DeleteContactAsync(TLAbsInputUser user, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestDeleteContact {Id = user};
return await SendAuthenticatedRequestAsync<TLLink>(req);
return await SendAuthenticatedRequestAsync<TLLink>(req, token)
.ConfigureAwait(false);
}
public async Task<TLContacts> GetContactsAsync()
public async Task<TLContacts> GetContactsAsync(CancellationToken token = default(CancellationToken))
{
var req = new TLRequestGetContacts() { Hash = "" };
return await SendAuthenticatedRequestAsync<TLContacts>(req);
return await SendAuthenticatedRequestAsync<TLContacts>(req, token)
.ConfigureAwait(false);
}
public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message)
public async Task<TLAbsUpdates> SendMessageAsync(TLAbsInputPeer peer, string message, CancellationToken token = default(CancellationToken))
{
return await SendAuthenticatedRequestAsync<TLAbsUpdates>(
new TLRequestSendMessage()
{
Peer = peer,
Message = message,
RandomId = Helpers.GenerateRandomLong()
});
new TLRequestSendMessage()
{
Peer = peer,
Message = message,
RandomId = Helpers.GenerateRandomLong()
}, token)
.ConfigureAwait(false);
}
public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer)
public async Task<Boolean> SendTypingAsync(TLAbsInputPeer peer, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestSetTyping()
{
Action = new TLSendMessageTypingAction(),
Peer = peer
};
return await SendRequestAsync<Boolean>(req);
return await SendAuthenticatedRequestAsync<Boolean>(req, token)
.ConfigureAwait(false);
}
public async Task<TLAbsDialogs> GetUserDialogsAsync(int offsetDate = 0, int offsetId = 0, TLAbsInputPeer offsetPeer = null, int limit = 100)
public async Task<TLAbsDialogs> GetUserDialogsAsync(int offsetDate = 0, int offsetId = 0, TLAbsInputPeer offsetPeer = null, int limit = 100, CancellationToken token = default(CancellationToken))
{
if (offsetPeer == null)
offsetPeer = new TLInputPeerSelf();
@ -319,58 +335,63 @@ namespace TLSharp.Core
OffsetPeer = offsetPeer,
Limit = limit
};
return await SendAuthenticatedRequestAsync<TLAbsDialogs>(req);
return await SendAuthenticatedRequestAsync<TLAbsDialogs>(req, token)
.ConfigureAwait(false);
}
public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption)
public async Task<TLAbsUpdates> SendUploadedPhoto(TLAbsInputPeer peer, TLAbsInputFile file, string caption, CancellationToken token = default(CancellationToken))
{
return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{
RandomId = Helpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TLInputMediaUploadedPhoto() { File = file, Caption = caption },
Peer = peer
});
return await SendAuthenticatedRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{
RandomId = Helpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TLInputMediaUploadedPhoto() { File = file, Caption = caption },
Peer = peer
}, token)
.ConfigureAwait(false);
}
public async Task<TLAbsUpdates> SendUploadedDocument(
TLAbsInputPeer peer, TLAbsInputFile file, string caption, string mimeType, TLVector<TLAbsDocumentAttribute> attributes)
TLAbsInputPeer peer, TLAbsInputFile file, string caption, string mimeType, TLVector<TLAbsDocumentAttribute> attributes, CancellationToken token = default(CancellationToken))
{
return await SendRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{
RandomId = Helpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TLInputMediaUploadedDocument()
return await SendAuthenticatedRequestAsync<TLAbsUpdates>(new TLRequestSendMedia()
{
File = file,
Caption = caption,
MimeType = mimeType,
Attributes = attributes
},
Peer = peer
});
RandomId = Helpers.GenerateRandomLong(),
Background = false,
ClearDraft = false,
Media = new TLInputMediaUploadedDocument()
{
File = file,
Caption = caption,
MimeType = mimeType,
Attributes = attributes
},
Peer = peer
}, token)
.ConfigureAwait(false);
}
public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0)
public async Task<TLFile> GetFile(TLAbsInputFileLocation location, int filePartSize, int offset = 0, CancellationToken token = default(CancellationToken))
{
TLFile result = null;
result = await SendRequestAsync<TLFile>(new TLRequestGetFile()
{
Location = location,
Limit = filePartSize,
Offset = offset
});
result = await SendAuthenticatedRequestAsync<TLFile>(new TLRequestGetFile
{
Location = location,
Limit = filePartSize,
Offset = offset
}, token)
.ConfigureAwait(false);
return result;
}
public async Task SendPingAsync()
public async Task SendPingAsync(CancellationToken token = default(CancellationToken))
{
await _sender.SendPingAsync();
await _sender.SendPingAsync(token)
.ConfigureAwait(false);
}
public async Task<TLAbsMessages> GetHistoryAsync(TLAbsInputPeer peer, int offsetId = 0, int offsetDate = 0, int addOffset = 0, int limit = 100, int maxId = 0, int minId = 0)
public async Task<TLAbsMessages> GetHistoryAsync(TLAbsInputPeer peer, int offsetId = 0, int offsetDate = 0, int addOffset = 0, int limit = 100, int maxId = 0, int minId = 0, CancellationToken token = default(CancellationToken))
{
var req = new TLRequestGetHistory()
{
@ -382,7 +403,8 @@ namespace TLSharp.Core
MaxId = maxId,
MinId = minId
};
return await SendAuthenticatedRequestAsync<TLAbsMessages>(req);
return await SendAuthenticatedRequestAsync<TLAbsMessages>(req, token)
.ConfigureAwait(false);
}
/// <summary>
@ -391,7 +413,7 @@ namespace TLSharp.Core
/// <param name="q">User or chat name</param>
/// <param name="limit">Max result count</param>
/// <returns></returns>
public async Task<TLFound> SearchUserAsync(string q, int limit = 10)
public async Task<TLFound> SearchUserAsync(string q, int limit = 10, CancellationToken token = default(CancellationToken))
{
var r = new TeleSharp.TL.Contacts.TLRequestSearch
{
@ -399,7 +421,8 @@ namespace TLSharp.Core
Limit = limit
};
return await SendRequestAsync<TLFound>(r);
return await SendAuthenticatedRequestAsync<TLFound>(r, token)
.ConfigureAwait(false);
}
private void OnUserAuthenticated(TLUser TLUser)

17
TLSharp.Core/Utils/UploadHelper.cs
View file

@ -4,6 +4,7 @@ using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using TeleSharp.TL;
using TeleSharp.TL.Upload;
@ -29,10 +30,10 @@ namespace TLSharp.Core.Utils
return md5_checksum;
}
public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name, StreamReader reader)
public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name, StreamReader reader, CancellationToken token = default(CancellationToken))
{
const long tenMb = 10 * 1024 * 1024;
return await UploadFile(name, reader, client, reader.BaseStream.Length >= tenMb);
return await UploadFile(name, reader, client, reader.BaseStream.Length >= tenMb, token).ConfigureAwait(false);
}
private static byte[] GetFile(StreamReader reader)
@ -77,8 +78,10 @@ namespace TLSharp.Core.Utils
}
private static async Task<TLAbsInputFile> UploadFile(string name, StreamReader reader,
TelegramClient client, bool isBigFileUpload)
TelegramClient client, bool isBigFileUpload, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
var file = GetFile(reader);
var fileParts = GetFileParts(file);
@ -91,22 +94,22 @@ namespace TLSharp.Core.Utils
if (isBigFileUpload)
{
await client.SendRequestAsync<bool>(new TLRequestSaveBigFilePart
await client.SendAuthenticatedRequestAsync<bool>(new TLRequestSaveBigFilePart
{
FileId = file_id,
FilePart = partNumber,
Bytes = part,
FileTotalParts = partsCount
});
}, token).ConfigureAwait(false);
}
else
{
await client.SendRequestAsync<bool>(new TLRequestSaveFilePart
await client.SendAuthenticatedRequestAsync<bool>(new TLRequestSaveFilePart
{
FileId = file_id,
FilePart = partNumber,
Bytes = part
});
}, token).ConfigureAwait(false);
}
partNumber++;
}