private async Task RequestWithDcMigration(TLMethod request)
{
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
var completed = false;
while (!completed)
{
try
{
await _sender.Send(request);
await _sender.Receive(request);
completed = true;
}
catch (DataCenterMigrationException e)
{
if (_session.DataCenter.DataCenterId.HasValue &&
_session.DataCenter.DataCenterId.Value == e.DC)
{
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);
// prepare the request for another try
request.ConfirmReceived = false;
}
}
}
public async Task SendRpcRequest(TLMethod request)
{
await _sender.Send(request);
// error handling order is important
await HandleError(request);
_session.Save();
// escalate to user
request.ThrowIfHasError();
}
public async Task <bool> Connect(bool reconnect = false)
{
if (_transport == null)
{
_transport = new TcpTransport(_session.ServerAddress, _session.Port);
}
if (_session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(_transport);
_session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset;
}
_sender = new MtProtoSender(_transport, _session);
if (!reconnect)
{
var request = new InitConnectionRequest(_apiId);
await _sender.Send(request);
await _sender.Recieve(request);
dcOptions = request.ConfigConstructor.dc_options;
_session.CurrentDcId = request.ConfigConstructor.this_dc;
}
return(true);
}
private async Task RequestWithDcMigration(TLMethod request)
{
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
var completed = false;
while (!completed)
{
try
{
await _sender.Send(request);
await _sender.Receive(request);
completed = true;
}
catch (DataCenterMigrationException e)
{
await ReconnectToDcAsync(e.DC);
// prepare the request for another try
request.ConfirmReceived = false;
}
}
}
public async Task <bool> Connect(bool reconnect = false)
{
if (_session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(_transport);
_session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset;
}
_sender = new MtProtoSender(_transport, _session);
if (!reconnect)
{
var request = new TL.InvokeWithLayerRequest(config.currentLayer,
new TL.InitConnectionRequest(config.apiId, config.DeviceModel, config.SystemVersion, config.AppVersion, config.LangCode,
new TL.HelpGetConfigRequest()));
await _sender.Send(request);
await _sender.Receive(request);
var result = (TL.ConfigType)request.Result;
dcOptions = result.DcOptions;
}
return(true);
}
public async Task <bool> ConnectAsync(bool reconnect = false)
{
if (_session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(_transport);
_session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset;
}
_sender = new MtProtoSender(_transport, _session);
//set-up layer
var config = new TLRequestGetConfig();
var request = new TLRequestInitConnection()
{
api_id = _apiId, app_version = "1.0.0", device_model = "PC", lang_code = "en", query = config, system_version = "Win 10.0"
};
var invokewithLayer = new TLRequestInvokeWithLayer()
{
layer = 57, query = request
};
await _sender.Send(invokewithLayer);
await _sender.Receive(invokewithLayer);
dcOptions = ((TLConfig)invokewithLayer.Response).dc_options.lists;
return(true);
}
public async Task ConnectAsync(bool reconnect = false, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
if (session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(transport, token).ConfigureAwait(false);
session.AuthKey = result.AuthKey;
session.TimeOffset = result.TimeOffset;
}
sender = new MtProtoSender(transport, session);
//set-up layer
var config = new TLRequestGetConfig();
var request = new TLRequestInitConnection()
{
ApiId = apiId,
AppVersion = "1.0.0",
DeviceModel = "PC",
LangCode = "en",
Query = config,
SystemVersion = "Win 10.0"
};
var invokewithLayer = new TLRequestInvokeWithLayer()
{
Layer = 66, Query = request
};
await sender.Send(invokewithLayer, token).ConfigureAwait(false);
await sender.Receive(invokewithLayer, token).ConfigureAwait(false);
dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
}
public async Task <bool> ConnectAsync(bool reconnect = false)
{
if (_session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(_transport);
_session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset;
}
_sender = new MtProtoSender(_transport, _session);
//set-up layer
var config = new TLRequestGetConfig();
var request = new TLRequestInitConnection()
{
ApiId = _apiId,
AppVersion = "1.0.0",
DeviceModel = "PC",
LangCode = "en",
Query = config,
SystemVersion = "Win 10.0"
};
var invokewithLayer = new TLRequestInvokeWithLayer()
{
Layer = 66, Query = request
};
await _sender.Send(invokewithLayer);
await _sender.Receive(invokewithLayer);
dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
return(true);
}
public async Task <bool> IsPhoneRegisteredAsync(string phoneNumber)
{
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
var authCheckPhoneRequest = new TLRequestCheckPhone()
{
phone_number = phoneNumber
};
await _sender.Send(authCheckPhoneRequest);
await _sender.Receive(authCheckPhoneRequest);
return(authCheckPhoneRequest.Response.phone_registered);
}
public async Task <string> SendCodeRequest(string phoneNumber)
{
retry:
var request = new Auth_SendCodeRequest(phoneNumber, 5, // 5 = app code
Values.ApiID, Values.ApiHash, "en");
await _sender.Send(request);
await _sender.Recieve(request);
var result = (Auth_sentAppCodeConstructor)request.result;
if (result == null)
{
goto retry; // we probs had a phone migrate error!
}
return(result.phone_code_hash);
}
public async Task <TL.ConfigType> getConfig()
{
var request = new TL.HelpGetConfigRequest();
await _sender.Send(request);
await _sender.Receive(request);
return((TL.ConfigType)request.Result);
}
public async Task <bool> IsPhoneRegisteredAsync(string phoneNumber)
{
if (String.IsNullOrWhiteSpace(phoneNumber))
{
throw new ArgumentNullException(nameof(phoneNumber));
}
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
var authCheckPhoneRequest = new TLRequestCheckPhone()
{
phone_number = phoneNumber
};
var completed = false;
while (!completed)
{
try
{
await _sender.Send(authCheckPhoneRequest);
await _sender.Receive(authCheckPhoneRequest);
completed = true;
}
catch (PhoneMigrationException e)
{
await ReconnectToDcAsync(e.DC);
}
}
return(authCheckPhoneRequest.Response.ToTLCheckedPhone().phone_registered);
}
public async Task <bool> IsPhoneRegistered(string phoneNumber)
{
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
var authCheckPhoneRequest = new AuthCheckPhoneRequest(phoneNumber);
await _sender.Send(authCheckPhoneRequest);
await _sender.Recieve(authCheckPhoneRequest);
return(authCheckPhoneRequest._phoneRegistered);
}
public async Task SendRpcRequest(MtProtoRequest request, bool throwOnError = true)
{
if (isClosed)
{
throw new ObjectDisposedException("TelegramClient is closed");
}
await protoSender.Send(request);
// handle errors that can be fixed without user interaction
if (request.Error == RpcRequestError.IncorrectServerSalt)
{
// assuming that salt was already updated by underlying layer
Debug.WriteLine("IncorrectServerSalt. Resolving by resending message");
request.ResetError();
await protoSender.Send(request);
}
if (request.Error == RpcRequestError.MessageSeqNoTooLow)
{
Debug.WriteLine("MessageSeqNoTooLow. Resoliving by resetting session and resending message");
session.Reset();
request.ResetError();
await protoSender.Send(request);
}
if (request.Error == RpcRequestError.Unauthorized)
{
Debug.WriteLine("Invalid authorization");
session.ResetAuth();
OnAuthenticationCanceled();
}
session.Save();
// escalate
if (throwOnError)
{
request.ThrowIfHasError();
}
}
private async Task <MtProtoSender> CreateProto(Session protoSession)
{
Debug.WriteLine("Creating new transport..");
if (protoSession.authKey == null)
{
var authResult = await Authenticator.Authenticate(protoSession.serverAddress, protoSession.port);
protoSession.authKey = authResult.authKey;
protoSession.timeOffset = authResult.timeOffset;
protoSession.salt = authResult.serverSalt;
}
var proto = new MtProtoSender(protoSession, true);
var initRequest = new InitConnectionAndGetConfigRequest(apiLayer, apiId, deviceInfo);
await proto.Send(initRequest);
return(proto);
}
private async Task RequestWithDcMigration(TLMethod request)
{
var completed = false;
while (!completed)
{
try
{
await _sender.Send(request);
await _sender.Receive(request);
completed = true;
}
catch (DataCenterMigrationException e)
{
await ReconnectToDcAsync(e.DC);
}
}
}
public async Task <bool> Connect()
{
if (_session.AuthKey == null)
{
var result = await Authenticator.DoAuthentication(_transport);
_session.AuthKey = result.AuthKey;
_session.TimeOffset = result.TimeOffset;
}
_sender = new MtProtoSender(_transport, _session);
var request = new InitConnectionRequest(Values.ApiID);
await _sender.Send(request);
await _sender.Recieve(request);
return(IsUserAuthorized());
}
public async Task <bool> IsPhoneRegistered(string phoneNumber)
{
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
var authCheckPhoneRequest = new TL.AuthCheckPhoneRequest(phoneNumber);
await _sender.Send(authCheckPhoneRequest);
await _sender.Receive(authCheckPhoneRequest);
var result = (TL.AuthCheckedPhoneType)authCheckPhoneRequest.Result;
return(result.PhoneRegistered);
}
private async Task ConnectInternalAsync(bool reconnect = false, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
Session = SessionFactory.TryLoadOrCreateNew(store, sessionUserId);
transport = new TcpTransport(Session.DataCenter.Address, Session.DataCenter.Port, this.handler);
if (Session.AuthKey == null || reconnect)
{
var result = await Authenticator.DoAuthentication(transport, token).ConfigureAwait(false);
Session.AuthKey = result.AuthKey;
Session.TimeOffset = result.TimeOffset;
}
sender = new MtProtoSender(transport, store, Session);
//set-up layer
var config = new TLRequestGetConfig();
var request = new TLRequestInitConnection()
{
ApiId = apiId,
AppVersion = "1.0.0",
DeviceModel = "PC",
LangCode = "en",
Query = config,
SystemVersion = "Win 10.0",
SystemLangCode = "en",
LangPack = ""
};
var invokewithLayer = new TLRequestInvokeWithLayer()
{
Layer = 108, Query = request
};
await sender.Send(invokewithLayer, token).ConfigureAwait(false);
await sender.Receive(invokewithLayer, token).ConfigureAwait(false);
dcOptions = ((TLConfig)invokewithLayer.Response).DcOptions.ToList();
}
public async Task <bool> IsPhoneRegistered(string phoneNumber)
{
if (_sender == null)
{
throw new InvalidOperationException("Not connected!");
}
bool completed = false;
AuthCheckPhoneRequest authCheckPhoneRequest = null;
while (!completed)
{
authCheckPhoneRequest = new AuthCheckPhoneRequest(phoneNumber);
try
{
await _sender.Send(authCheckPhoneRequest);
await _sender.Recieve(authCheckPhoneRequest);
completed = true;
}
catch (InvalidOperationException e)
{
if (e.Message.StartsWith("Your phone number registered to") && e.Data["dcId"] != null)
{
await ReconnectToDc((int)e.Data["dcId"]);
}
else
{
throw;
}
}
}
return(authCheckPhoneRequest._phoneRegistered);
}
public async Task <Tuple <List <Dialog>, List <Message>, List <Chat>, List <User> > > getDialogs(int offset, int limit)
{
var request = new TL.ChannelsGetDialogsRequest(offset, limit);
await _sender.Send(request);
await _sender.Receive(request);
if (request.Result is TL.MessagesDialogsType)
{
var result = (TL.MessagesDialogsType)request.Result;
dialogs = result.Dialogs;
messages = result.Messages;
chats = result.Chats;
users = result.Users;
}
else
{
var result = (TL.MessagesDialogsSliceType)request.Result;
dialogs = result.Dialogs;
messages = result.Messages;
chats = result.Chats;
users = result.Users;
}
return(new Tuple <List <Dialog>, List <Message>, List <Chat>, List <User> >(dialogs, messages, chats, users));
}
