public static async void NavigateToProxy(IProtoService protoService, string server, int port, string username, string password, string secret)
{
var userText = username != null ? $"{Strings.Resources.UseProxyUsername}: {username}\n" : string.Empty;
var passText = password != null ? $"{Strings.Resources.UseProxyPassword}: {password}\n" : string.Empty;
var secretText = secret != null ? $"{Strings.Resources.UseProxySecret}: {secret}\n" : string.Empty;
var secretInfo = secret != null ? $"\n\n{Strings.Resources.UseProxyTelegramInfo2}" : string.Empty;
var confirm = await TLMessageDialog.ShowAsync($"{Strings.Resources.EnableProxyAlert}\n\n{Strings.Resources.UseProxyAddress}: {server}\n{Strings.Resources.UseProxyPort}: {port}\n{userText}{passText}{secretText}\n{Strings.Resources.EnableProxyAlert2}{secretInfo}", Strings.Resources.Proxy, Strings.Resources.ConnectingConnectProxy, Strings.Resources.Cancel);
if (confirm == ContentDialogResult.Primary)
{
ProxyType type;
if (secret != null)
{
type = new ProxyTypeMtproto(secret);
}
else
{
type = new ProxyTypeSocks5(username ?? string.Empty, password ?? string.Empty);
}
protoService.Send(new AddProxy(server ?? string.Empty, port, true, type));
}
}
/// <summary>
/// initializes api instance
/// </summary>
/// <param name="debugMode">determines if software is in debug mode</param>
/// <param name="token">cancellation token to stop tasks</param>
internal void Initialize(bool debugMode, CancellationToken token)
{
#region tdlib log file path
// file to write tdlib log in
string tdlibLogFilePath = $"tdlibLog-{_setting.name}.txt";
// setting log file path
if (tdLib.Client.Execute(new tdApi.SetLogStream(new tdApi.LogStreamFile(tdlibLogFilePath, 1 << 27, false))) is tdApi.Error)
{
throw new System.IO.IOException("Write access to the current directory is required");
}
#endregion tdlib log file path
// disabling log if software is not in debug mode
if (!debugMode)
{
// fatal errors only
tdLib.Client.Execute(new tdApi.SetLogVerbosityLevel(0));
}
#region adding some global handlers
addGlobalHandler(typeof(UpdateAuthorizationState), async(obj) =>
{
// casting update
AuthorizationState authorizationState = (obj as UpdateAuthorizationState).AuthorizationState;
if (authorizationState is AuthorizationStateClosed)
{
_authorizationState = Enum.AuhtorizationState.Closed;
}
else if (authorizationState is AuthorizationStateClosing)
{
_authorizationState = Enum.AuhtorizationState.Closing;
}
else if (authorizationState is AuthorizationStateLoggingOut)
{
_authorizationState = Enum.AuhtorizationState.LoggingOut;
}
else if (authorizationState is AuthorizationStateReady)
{
_authorizationState = Enum.AuhtorizationState.Ready;
// check if function to call when state is ready is set
if (onReady is null)
{
throw new Exception("There is no function call when authentication is ready is not set");
}
// invoking function
onReady.Invoke(this);
}
else if (authorizationState is AuthorizationStateWaitEncryptionKey)
{
_authorizationState = Enum.AuhtorizationState.BackgroundActions;
await executeCommand(new CheckDatabaseEncryptionKey(), typeof(Ok));
#region set proxy
// check if proxy setting exists
if (_setting.proxy != null)
{
ProxyType type;
switch (_setting.proxy.type)
{
case Enum.ProxyType.MTProto:
type = new ProxyTypeMtproto();
break;
case Enum.ProxyType.Socks5:
type = new ProxyTypeSocks5();
break;
default:
type = new ProxyTypeHttp();
break;
}
// sending and enabling proxy
var res = await executeCommand(new AddProxy(_setting.proxy.ip, _setting.proxy.port, true, type), typeof(Proxy));
if (res.status == Enum.ResponseStatus.Success)
{
Logger.Debug("proxy enabled successfully");
}
else
{
Logger.Debug("proxy enabling failed, => {0}", res.obj.JSONSerialize());
}
}
else
{
// disabling proxy
var res = await executeCommand(new DisableProxy());
if (res.status == Enum.ResponseStatus.Success)
{
Logger.Debug("proxy disabled successfully");
}
else
{
Logger.Debug("proxy enabdisabledling failed, => {0}", res.obj.JSONSerialize());
}
}
#endregion set proxy
}
else if (authorizationState is AuthorizationStateWaitOtherDeviceConfirmation)
{
_authorizationState = Enum.AuhtorizationState.BackgroundActions;
}
else if (authorizationState is AuthorizationStateWaitPhoneNumber)
{
_authorizationState = Enum.AuhtorizationState.WaitingForPhoneNumber;
// check if function to get phone number is set
if (onPhoneNumberRequired is null)
{
throw new Exception("There is no function to get phone number from");
}
runLocked(async() =>
{
// gathering phone number
string phoneNumber = onPhoneNumberRequired(_setting.name);
await executeCommand(new SetAuthenticationPhoneNumber(phoneNumber, new PhoneNumberAuthenticationSettings()
{
AllowFlashCall = true,
AllowSmsRetrieverApi = true
}));
});
}
else if (authorizationState is AuthorizationStateWaitCode)
{
_authorizationState = Enum.AuhtorizationState.WaitingForVerificationCode;
// check if function to get phone number is set
if (onVerificationCodeRequired is null)
{
throw new Exception("There is no function to get verification code from");
}
runLocked(async() =>
{
// gathering verification code form user provided function
string code = onVerificationCodeRequired(_setting.name);
await executeCommand(new CheckAuthenticationCode(code));
});
}
else if (authorizationState is AuthorizationStateWaitPassword)
{
_authorizationState = Enum.AuhtorizationState.WaitingForVerificationPassword;
// check if function to get password is set
if (onPasswordRequired is null)
{
throw new Exception("There is no function to get password from");
}
runLocked(async() =>
{
// gathering password form user provided function
string password = onPasswordRequired(_setting.name);
await executeCommand(new CheckAuthenticationPassword(password));
});
}
else if (authorizationState is AuthorizationStateWaitTdlibParameters)
{
_authorizationState = Enum.AuhtorizationState.BackgroundActions;
var res = await executeCommand(new SetTdlibParameters(new TdlibParameters()
{
ApiHash = _setting.api_hash,
ApiId = _setting.api_id,
ApplicationVersion = "1.3.1",
DeviceModel = "Desktop",
SystemLanguageCode = "en",
UseSecretChats = true,
UseMessageDatabase = true,
UseChatInfoDatabase = true,
EnableStorageOptimizer = true,
DatabaseDirectory = $"TDLibCoreData-{_setting.name}"
}), typeof(Ok));
}
else
{
_authorizationState = Enum.AuhtorizationState.InvalidData;
}
});
addGlobalHandler(typeof(UpdateConnectionState), (obj) =>
{
// casting update
ConnectionState update = (obj as UpdateConnectionState).State;
if (update is ConnectionStateConnecting)
{
_connectionState = Enum.ConnectionState.Connecting;
}
else if (update is ConnectionStateConnectingToProxy)
{
_connectionState = Enum.ConnectionState.ConnectingToProxy;
}
else if (update is ConnectionStateReady)
{
_connectionState = Enum.ConnectionState.Connected;
}
else if (update is ConnectionStateUpdating)
{
_connectionState = Enum.ConnectionState.Updating;
}
else if (update is ConnectionStateWaitingForNetwork)
{
_connectionState = Enum.ConnectionState.WaitingForNetwork;
}
else
{
_connectionState = Enum.ConnectionState.InvalidData;
}
});
#endregion adding some global handlers
// we run core only if it's first time in whole application
if (!tdlibInitialized)
{
// starting client
_ = Task.Factory.StartNew(() =>
{
// we run core
tdLib.Client.Run();
}, token);
// preventing from double running tdlib
tdlibInitialized = true;
}
// generating clinet instance
_client = tdLib.Client.Create(_responseHandler);
_initialized = true;
}