private static WebView CreateWebView(Window window, BrowserOptions options, TaskCompletionSource <BrowserResult> tcs)
{
var webView = new WebView();
webView.NavigationStarting += (sender, e) =>
{
if (e.Uri.AbsoluteUri.StartsWith(options.EndUrl))
{
tcs.SetResult(new BrowserResult {
ResultType = BrowserResultType.Success, Response = e.Uri.ToString()
});
window.Close();
}
};
// There is no closed event so the best we can do is detect visibility. This means we close when they minimize too.
window.VisibilityChanged += (sender, e) =>
{
if (!window.Visible && !tcs.Task.IsCompleted)
{
tcs.SetResult(new BrowserResult {
ResultType = BrowserResultType.UserCancel
});
window.Close();
}
};
window.Content = webView;
window.Activate();
return(webView);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
using (var listener = new LoopbackHttpListener(Port, _path))
{
OpenBrowser(options.StartUrl);
try
{
var result = await listener.WaitForCallbackAsync();
if (String.IsNullOrWhiteSpace(result))
{
return(new BrowserResult {
ResultType = BrowserResultType.UnknownError, Error = "Empty response."
});
}
return(new BrowserResult {
Response = result, ResultType = BrowserResultType.Success
});
}
catch (TaskCanceledException ex)
{
return(new BrowserResult {
ResultType = BrowserResultType.Timeout, Error = ex.Message
});
}
catch (Exception ex)
{
return(new BrowserResult {
ResultType = BrowserResultType.UnknownError, Error = ex.Message
});
}
}
}
/// <summary>
/// Open a browser to a specific url
/// </summary>
/// <param name="url">Url to open</param>
/// <param name="options">Platform specific options</param>
/// <returns>awaitable Task</returns>
public async Task OpenBrowser(string url, BrowserOptions options = null)
{
try
{
if (options == null)
{
options = new BrowserOptions();
}
if ((options?.UseSafariWebViewController ?? false) && UIDevice.CurrentDevice.CheckSystemVersion(9, 0))
{
var sfViewController = new SafariServices.SFSafariViewController(new NSUrl(url), options?.UseSafairReaderMode ?? false);
var vc = GetVisibleViewController();
if (sfViewController.PopoverPresentationController != null)
{
sfViewController.PopoverPresentationController.SourceView = vc.View;
}
await vc.PresentViewControllerAsync(sfViewController, true);
}
else
{
UIApplication.SharedApplication.OpenUrl(new NSUrl(url));
}
}
catch (Exception ex)
{
Console.WriteLine("Unable to open browser: " + ex.Message);
}
}
public Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
var tcs = new TaskCompletionSource <BrowserResult>();
try
{
_asWebAuthenticationSession = new ASWebAuthenticationSession(
new NSUrl(options.StartUrl),
options.EndUrl,
(callbackUrl, error) =>
{
tcs.SetResult(CreateBrowserResult(callbackUrl, error));
_asWebAuthenticationSession.Dispose();
});
// iOS 13 requires the PresentationContextProvider set
if (UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
{
_asWebAuthenticationSession.PresentationContextProvider = new PresentationContextProviderToSharedKeyWindow();
}
_asWebAuthenticationSession.Start();
}
catch (Exception ex)
{
throw ex;
}
return(tcs.Task);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
try
{
var callbackUrl = string.IsNullOrEmpty(_callbackUrl) ? options.EndUrl : _callbackUrl;
WebAuthenticatorResult authResult =
// await WebAuthenticator.AuthenticateAsync(new Uri(options.StartUrl), new Uri(callbackUrl));
await WebAuthenticator.AuthenticateAsync(new WebAuthenticatorOptions
{
Url = new Uri(options.StartUrl),
CallbackUrl = new Uri(callbackUrl),
PrefersEphemeralWebBrowserSession = true
});
var authorizeResponse = ToRawIdentityUrl(options.EndUrl, authResult);
return(new BrowserResult
{
Response = authorizeResponse
});
}
catch (Exception ex)
{
Debug.WriteLine(ex);
return(new BrowserResult()
{
ResultType = BrowserResultType.UnknownError,
Error = ex.ToString()
});
}
}
/// </inheritdoc>
public Task<BrowserResult> InvokeAsync(BrowserOptions options)
{
var tcs = new TaskCompletionSource<BrowserResult>();
var window = _formFactory();
var webView = new WebViewCompatible { Dock = DockStyle.Fill };
webView.NavigationStarting += (sender, e) =>
{
if (e.Uri.AbsoluteUri.StartsWith(options.EndUrl))
{
tcs.SetResult(new BrowserResult { ResultType = BrowserResultType.Success, Response = e.Uri.ToString() });
window.Close();
}
};
window.Closing += (sender, e) =>
{
if (!tcs.Task.IsCompleted)
tcs.SetResult(new BrowserResult { ResultType = BrowserResultType.UserCancel });
};
window.Controls.Add(webView);
window.Show();
webView.Navigate(options.StartUrl);
return tcs.Task;
}
// Token: 0x06000554 RID: 1364 RVA: 0x0002DDF4 File Offset: 0x0002BFF4
private void clearsession_button_Click(object sender, EventArgs e)
{
GClass0 gclass = CaptchaQueue.dictionary_1[CaptchaQueue.int_0];
WebView webView = gclass.webView_0;
webView.Engine.Stop(true);
webView.Dispose();
Engine engine = gclass.webView_0.Engine;
BrowserOptions options = new BrowserOptions
{
EnableXSSAuditor = new bool?(false),
EnableWebSecurity = new bool?(false)
};
webView = new WebView();
webView.SetOptions(options);
webView.Engine = engine;
webView.Engine.AllowRestart = true;
webView.Create(gclass.panel_0.Handle);
webView.RegisterJSExtensionFunction("submit", new JSExtInvokeHandler(this.method_3));
webView.CertificateError += this.method_11;
webView.BeforeContextMenu += this.method_10;
CaptchaQueue.dictionary_1[CaptchaQueue.int_0].webView_0 = webView;
this.reloadCaptcha_Click(null, null);
}
/// <inheritdoc/>
public async Task <BrowserResultType> LogoutAsync(bool federated = false, object extraParameters = null)
{
Debug.WriteLine($"Using Callback URL ${_options.PostLogoutRedirectUri}. Ensure this is an Allowed Logout URL for application/client ID ${_options.ClientId}.");
var logoutParameters = AppendTelemetry(extraParameters);
logoutParameters["client_id"] = OidcClient.Options.ClientId;
logoutParameters["returnTo"] = OidcClient.Options.PostLogoutRedirectUri;
var endSessionUrl = new RequestUrl($"https://{_options.Domain}/v2/logout").Create(logoutParameters);
if (federated)
{
endSessionUrl += "&federated";
}
var logoutRequest = new LogoutRequest();
var browserOptions = new BrowserOptions(endSessionUrl, OidcClient.Options.PostLogoutRedirectUri ?? string.Empty)
{
Timeout = TimeSpan.FromSeconds(logoutRequest.BrowserTimeout),
DisplayMode = logoutRequest.BrowserDisplayMode
};
var browserResult = await OidcClient.Options.Browser.InvokeAsync(browserOptions);
return(browserResult.ResultType);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options)
{
// create an HttpListener to listen for requests on the redirect URI.
using (var listener = new HttpListener())
{
listener.Prefixes.Add(options.EndUrl);
listener.Start();
// Start the browser
Process.Start(options.StartUrl);
// wait for the authorization response.
var context = await listener.GetContextAsync();
// sends an HTTP response to the browser.
var response = context.Response;
string responseString =
"<html><head><meta http-equiv=\'refresh\'></head><body>Authentication is completed. You can now close the browser and return to the application.</body></html>";
var buffer = Encoding.UTF8.GetBytes(responseString);
response.ContentLength64 = buffer.Length;
var responseOutput = response.OutputStream;
await responseOutput.WriteAsync(buffer, 0, buffer.Length);
responseOutput.Close();
// Return the result
return(new BrowserResult
{
ResultType = BrowserResultType.Success,
Response = context.Request.Url.ToString()
});
}
}
public void KillDriver(BrowserOptions browser)
{
var driverProcess = new Process[] { };
switch (browser)
{
case BrowserOptions.Chrome:
driverProcess = Process.GetProcessesByName("chromedriver");
break;
case BrowserOptions.FireFox:
driverProcess = Process.GetProcessesByName("geckodriver");
break;
case BrowserOptions.IE:
driverProcess = Process.GetProcessesByName("IEDriverServer");
break;
case BrowserOptions.Edge:
driverProcess = Process.GetProcessesByName("MicrosoftWebDriver");
break;
}
if (driverProcess.Length > 0)
{
foreach (var driver in driverProcess)
{
driver.Kill();
}
}
}
/// <inheritdoc/>
public async Task <BrowserResultType> LogoutAsync(bool federated)
{
var logoutParameters = new Dictionary <string, string>
{
{ "client_id", OidcClient.Options.ClientId },
{ "returnTo", OidcClient.Options.PostLogoutRedirectUri }
};
var endSessionUrl = new RequestUrl($"https://{_options.Domain}/v2/logout").Create(logoutParameters);
if (federated)
{
endSessionUrl += "&federated";
}
var logoutRequest = new LogoutRequest();
var browserOptions = new BrowserOptions(endSessionUrl, OidcClient.Options.PostLogoutRedirectUri ?? string.Empty)
{
Timeout = TimeSpan.FromSeconds(logoutRequest.BrowserTimeout),
DisplayMode = logoutRequest.BrowserDisplayMode
};
var browserResult = await OidcClient.Options.Browser.InvokeAsync(browserOptions);
return(browserResult.ResultType);
}
private string GetDriverPath(BrowserOptions options)
{
string envWebDriver = null;
string driverFile = null;
switch (options.BrowserType)
{
case BrowserType.Chrome:
envWebDriver = Environment.GetEnvironmentVariable("ChromeWebDriver");
driverFile = "chromedriver.exe";
break;
case BrowserType.Firefox:
envWebDriver = Environment.GetEnvironmentVariable("GeckoWebDriver");
driverFile = "geckodriver.exe";
break;
case BrowserType.IE:
envWebDriver = Environment.GetEnvironmentVariable("IEWebDriver");
driverFile = "IEDriverServer.exe";
break;
}
if (!string.IsNullOrEmpty(envWebDriver) && File.Exists(Path.Combine(envWebDriver, driverFile)))
{
Logger.WriteLine($"Using driver path via environmentvariable. Driver path: {envWebDriver}");
return(envWebDriver);
}
else
{
var assemblyPath = new FileInfo(Assembly.GetExecutingAssembly().Location);
Logger.WriteLine($"Using chrome driver path: {assemblyPath.Directory}");
return(assemblyPath.DirectoryName);
}
}
public UCIBrowser GetBrowser(BrowserOptions options, BrowserLoginDetails browserLoginDetails)
{
Logger.WriteLine("Getting Browser");
if (!_browserCache.TryGetValue(options.BrowserType, out var dic))
{
Logger.WriteLine($"No browser for {options.BrowserType} doesn't exist. Creating new list");
dic = new Dictionary <string, UCIBrowser>();
_browserCache.Add(options.BrowserType, dic);
}
if (!dic.TryGetValue(browserLoginDetails.Username, out UCIBrowser browser))
{
Logger.WriteLine($"Browser for {browserLoginDetails.Username} doesn't exist. Creating new browser session");
if (string.IsNullOrEmpty(options.DriversPath))
{
options.DriversPath = GetDriverPath(options);
}
browser = new UCIBrowser(options, _buttonTexts, _appCache.Value);
dic.Add(browserLoginDetails.Username, browser);
browser.Login(browserLoginDetails);
}
return(browser);
}
public PowerPlatformAdminCenterBrowser(BrowserOptions options, ILogger logger, string sessionId)
{
Browser = new InteractiveBrowser(options);
OnlineDomains = Constants.Xrm.XrmDomains;
ClientSessionId = new Guid(sessionId);
_logger = logger;
}
internal static Task <BrowserResult> Start(BrowserOptions options, ASWebAuthenticationSessionOptions sessionOptions = null)
{
var tcs = new TaskCompletionSource <BrowserResult>();
ASWebAuthenticationSession asWebAuthenticationSession = null;
asWebAuthenticationSession = new ASWebAuthenticationSession(
new NSUrl(options.StartUrl),
new NSUrl(options.EndUrl).Scheme,
(callbackUrl, error) =>
{
tcs.SetResult(CreateBrowserResult(callbackUrl, error));
asWebAuthenticationSession.Dispose();
});
if (UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
{
// iOS 13 requires the PresentationContextProvider set
asWebAuthenticationSession.PresentationContextProvider = new PresentationContextProviderToSharedKeyWindow();
// PrefersEphemeralWebBrowserSession is only available on iOS 13 and up.
asWebAuthenticationSession.PrefersEphemeralWebBrowserSession = sessionOptions != null ? sessionOptions.PrefersEphemeralWebBrowserSession : false;
}
asWebAuthenticationSession.Start();
return(tcs.Task);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options)
{
using (var listener = new BrowserRequestHandler(_redirectUri))
{
OpenBrowser(options.StartUrl);
try
{
var result = await listener.WaitForCallbackAsync();
if (String.IsNullOrWhiteSpace(result))
{
return(new BrowserResult {
ResultType = BrowserResultType.UnknownError, Error = "Empty response."
});
}
return(new BrowserResult {
Response = result, ResultType = BrowserResultType.Success
});
}
catch (TaskCanceledException ex)
{
return(new BrowserResult {
ResultType = BrowserResultType.Timeout, Error = ex.Message
});
}
catch (Exception ex)
{
return(new BrowserResult {
ResultType = BrowserResultType.UnknownError, Error = ex.Message
});
}
}
}
internal static Task <BrowserResult> Start(BrowserOptions options)
{
var tcs = new TaskCompletionSource <BrowserResult>();
// Create Safari controller
var safari = new SFSafariViewController(new NSUrl(options.StartUrl))
{
Delegate = new SafariViewControllerDelegate()
};
async void Callback(string response)
{
ActivityMediator.Instance.ActivityMessageReceived -= Callback;
if (response == "UserCancel")
{
tcs.SetResult(Canceled());
}
else
{
await safari.DismissViewControllerAsync(true); // Close Safari
safari.Dispose();
tcs.SetResult(Success(response));
}
}
ActivityMediator.Instance.ActivityMessageReceived += Callback;
// Launch Safari
FindRootController().PresentViewController(safari, true, null);
return(tcs.Task);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
Guard.IsNotNullOrWhiteSpace(options.StartUrl, nameof(options.StartUrl));
Guard.IsNotNullOrWhiteSpace(options.EndUrl, nameof(options.EndUrl));
switch (options.DisplayMode)
{
case DisplayMode.Visible:
return(await InvokeAsyncCore(options, false));
case DisplayMode.Hidden:
var result = await InvokeAsyncCore(options, true);
if (result.ResultType == BrowserResultType.Success)
{
return(result);
}
else
{
result.ResultType = BrowserResultType.Timeout;
return(result);
}
default:
ThrowHelper.ThrowArgumentOutOfRangeException(nameof(options.DisplayMode));
return(null);
}
}
public UCIBrowser(BrowserOptions browserOptions, ButtonTexts buttonTexts, CrmModelApps apps)
{
App = new UCIApp(browserOptions, buttonTexts);
_forms = new Dictionary <string, FormData>();
_quickForms = new Dictionary <string, QuickFormData>();
_apps = apps;
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = new CancellationToken())
{
if (options == null)
{
throw new ArgumentException("Options cannot be null", nameof(options));
}
using var listener = new LoopbackHttpListener(Port, _path);
OpenBrowser.OpenBrowser(options.StartUrl, UserName, Password);
try
{
var result = await listener.WaitForCallbackAsync().ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(result))
{
return(new BrowserResult {
ResultType = BrowserResultType.UnknownError, Error = "Empty response."
});
}
return(new BrowserResult {
Response = result, ResultType = BrowserResultType.Success
});
}
catch (TaskCanceledException ex)
{
return(new BrowserResult {
ResultType = BrowserResultType.Timeout, Error = ex.Message
});
}
}
public async Task <AuthorizeResult> AuthorizeAsync(AuthorizeRequest request,
CancellationToken cancellationToken = default)
{
_logger.LogTrace("AuthorizeAsync");
if (_options.Browser == null)
{
throw new InvalidOperationException("No browser configured.");
}
AuthorizeResult result = new AuthorizeResult
{
State = CreateAuthorizeState(request.ExtraParameters)
};
var browserOptions = new BrowserOptions(result.State.StartUrl, _options.RedirectUri)
{
Timeout = TimeSpan.FromSeconds(request.Timeout),
DisplayMode = request.DisplayMode
};
var browserResult = await _options.Browser.InvokeAsync(browserOptions, cancellationToken);
if (browserResult.ResultType == BrowserResultType.Success)
{
result.Data = browserResult.Response;
return(result);
}
result.Error = browserResult.Error ?? browserResult.ResultType.ToString();
return(result);
}
public Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
var task = new TaskCompletionSource <BrowserResult>();
var builder = new CustomTabsIntent.Builder(_manager.Session)
.SetToolbarColor(Color.Argb(255, 52, 152, 219))
.SetShowTitle(true)
.EnableUrlBarHiding();
var customTabsIntent = builder.Build();
// ensures the intent is not kept in the history stack, which makes
// sure navigating away from it will close it
customTabsIntent.Intent.AddFlags(ActivityFlags.NoHistory);
Action <string> callback = null;
callback = url =>
{
OidcCallbackActivity.Callbacks -= callback;
task.SetResult(new BrowserResult()
{
Response = url
});
};
OidcCallbackActivity.Callbacks += callback;
customTabsIntent.LaunchUrl(_context, Android.Net.Uri.Parse(options.StartUrl));
return(task.Task);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options)
{
if (string.IsNullOrWhiteSpace(options.StartUrl))
{
throw new ArgumentException("Missing StartUrl", nameof(options));
}
var startUri = new Uri(options.StartUrl);
if (startUri.AbsolutePath.StartsWith("/v2/logout", StringComparison.OrdinalIgnoreCase))
{
return(await InvokeLogoutAsync(startUri));
}
try
{
var authOptions = ConfigureWebAuthOptions(options.DisplayMode);
var authResult = await WebAuthenticationBroker.AuthenticateAsync(authOptions, startUri, new Uri(options.EndUrl));
return(CreateBrowserResult(authResult));
}
catch (Exception ex)
{
return(new BrowserResult
{
ResultType = BrowserResultType.UnknownError,
Error = ex.ToString()
});
}
}
public Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
var wait = new TaskCompletionSource <BrowserResult>();
_sf = new SFAuthenticationSession(
new NSUrl(options.StartUrl),
options.EndUrl,
(callbackUrl, error) =>
{
if (error != null)
{
var errorResult = new BrowserResult
{
ResultType = BrowserResultType.UserCancel,
Error = error.ToString()
};
wait.SetResult(errorResult);
}
else
{
var result = new BrowserResult
{
ResultType = BrowserResultType.Success,
Response = callbackUrl.AbsoluteString
};
wait.SetResult(result);
}
});
_sf.Start();
return(wait.Task);
}
internal static Task <BrowserResult> Start(BrowserOptions options)
{
var tcs = new TaskCompletionSource <BrowserResult>();
ASWebAuthenticationSession asWebAuthenticationSession = null;
asWebAuthenticationSession = new ASWebAuthenticationSession(
new NSUrl(options.StartUrl),
options.EndUrl,
(callbackUrl, error) =>
{
tcs.SetResult(CreateBrowserResult(callbackUrl, error));
asWebAuthenticationSession.Dispose();
});
// iOS 13 requires the PresentationContextProvider set
if (UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
{
asWebAuthenticationSession.PresentationContextProvider = new PresentationContextProviderToSharedKeyWindow();
}
asWebAuthenticationSession.Start();
return(tcs.Task);
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken token = default)
{
using (var form = _formFactory.Invoke())
using (var browser = new ExtendedWebBrowser()
{
Dock = DockStyle.Fill
})
{
var signal = new SemaphoreSlim(0, 1);
var result = new BrowserResult
{
ResultType = BrowserResultType.UserCancel
};
form.FormClosed += (o, e) =>
{
signal.Release();
};
browser.NavigateError += (o, e) =>
{
if (e.Url.StartsWith(options.EndUrl))
{
e.Cancel = true;
result.ResultType = BrowserResultType.Success;
result.Response = e.Url;
signal.Release();
}
};
browser.DocumentCompleted += (o, e) =>
{
if (e.Url.AbsoluteUri.StartsWith(options.EndUrl))
{
result.ResultType = BrowserResultType.Success;
result.Response = e.Url.AbsoluteUri;
signal.Release();
}
};
try
{
form.Controls.Add(browser);
browser.Show();
form.Show();
browser.Navigate(options.StartUrl);
await signal.WaitAsync();
}
finally
{
form.Hide();
browser.Hide();
}
return(result);
}
}
public static Dictionary <string, Func <string[], Parser, string> > GetModuleRunner()
{
return(new Dictionary <string, Func <string[], Parser, string> > {
{
"TraceRoute", (args, parser) => {
var options = new TraceRouteOptions();
return VerifyArguments(parser, args, new TraceRouteModule(), options).Execute(options);
}
},
{
"NetworkInterface", (args, parser) =>
{
var options = new NetworkInterfaceOptions();
return VerifyArguments(parser, args, new NetworkInterfaceModule(), options).Execute(options);
}
},
{
"Browser", (args, parser) =>
{
var options = new BrowserOptions();
return VerifyArguments(parser, args, new BrowserModule(), options).Execute(options);
}
},
{
"OperatingSystem", (args, parser) =>
{
var options = new OperatingSystemOptions();
return VerifyArguments(parser, args, new OperatingSystemModule(), options).Execute(options);
}
},
{
"Ping", (args, parser) =>
{
var options = new PingOptions();
return VerifyArguments(parser, args, new PingModule(), options).Execute(options);
}
},
{
"SslCertificate", (args, parser) =>
{
var options = new SslCertificateOptions();
return VerifyArguments(parser, args, new SslCertificateModule(), options).Execute(options);
}
},
{
"WebSocket", (args, parser) =>
{
var options = new WebSocketOptions();
return VerifyArguments(parser, args, new WebSocketModule(), options).Execute(options);
}
},
{
"HTTP", (args, parser) =>
{
var options = new HttpOptions();
return VerifyArguments(parser, args, new HttpModule(), options).Execute(options);
}
}
});
}
/// <inheritdoc/>
public Task <BrowserResult> InvokeAsync(BrowserOptions options)
{
if (string.IsNullOrWhiteSpace(options.StartUrl))
{
throw new ArgumentException("Missing StartUrl", nameof(options));
}
if (string.IsNullOrWhiteSpace(options.EndUrl))
{
throw new ArgumentException("Missing EndUrl", nameof(options));
}
var tcs = new TaskCompletionSource <BrowserResult>();
void Callback(string response)
{
ActivityMediator.Instance.ActivityMessageReceived -= Callback;
var cancelled = response == "UserCancel";
tcs.SetResult(new BrowserResult
{
ResultType = cancelled ? BrowserResultType.UserCancel : BrowserResultType.Success,
Response = response
});
}
ActivityMediator.Instance.ActivityMessageReceived += Callback;
OpenBrowser(Android.Net.Uri.Parse(options.StartUrl), context ?? Application.Context);
return(tcs.Task);
}
private void Init(string url = null)
{
engine = Engine.Create(id);
engine.Options.AllowProprietaryMediaFormats();
engine.Options.CachePath = $"{id}";
threadRunner = new ThreadRunner(ID, engine);
BrowserOptions options = new BrowserOptions()
{
AllowJavaScript = true,
AllowPlugins = true,
AllowJavaScriptAccessClipboard = true,
AllowJavaScriptCloseWindow = true,
AllowJavaScriptDOMPaste = true,
AllowZooming = true,
};
webView = threadRunner.CreateWebView(defaultSize.Width, defaultSize.Height, options);
webView.CustomUserAgent = userAgent;
webView.NeedClientCertificate += WebView_NeedClientCertificate;
webView.CertificateError += WebView_CertificateError;
webView.LoadCompleted += WebView_LoadCompleted;
webView.LoadFailed += WebView_LoadFailed;
if (!String.IsNullOrEmpty(url))
{
TargetUrl = url;
UrlAsync = url;
UpdateCurrentUrl(url);
}
WriteLog($"Initialized: ID: {id} Cache: {engine.CachePath} Window Size: {defaultSize}");
}
public async Task <BrowserResult> InvokeAsync(BrowserOptions options, CancellationToken cancellationToken = default)
{
if (string.IsNullOrWhiteSpace(options.StartUrl))
{
throw new ArgumentException("Missing StartUrl", nameof(options));
}
if (string.IsNullOrWhiteSpace(options.EndUrl))
{
throw new ArgumentException("Missing EndUrl", nameof(options));
}
switch (options.DisplayMode)
{
case DisplayMode.Visible:
return(await InvokeAsyncCore(options, false));
case DisplayMode.Hidden:
var result = await InvokeAsyncCore(options, true);
if (result.ResultType == BrowserResultType.Success)
{
return(result);
}
else
{
result.ResultType = BrowserResultType.Timeout;
return(result);
}
}
throw new ArgumentException("Invalid DisplayMode", nameof(options));
}
public MainForm()
{
InitializeComponent();
var bo = new BrowserOptions();
bo.UserStyleSheet = @"#side.pane-list{width: 80px;}";
Runtime.SetDefaultOptions(bo);
//Cargar Configuracion
config = new Configuracion() {
correo = ConfigurationSettings.AppSettings["correo"],
pwd = ConfigurationSettings.AppSettings["pwd"],
imap = ConfigurationSettings.AppSettings["imap"],
puerto = Convert.ToInt32(ConfigurationSettings.AppSettings["puerto"]),
};
_t = new TrayIcon(this);
var wc = new WebControl { Dock = DockStyle.Fill, };
wc.WebView = new WebView{ Url = "m.facebook.com", };
var tp = new TabPage("Facebook");
tp.Controls.Add(wc);
tabControl1.TabPages.Add(tp);
var wc2 = new WebControl { Dock = DockStyle.Fill, };
wc2.WebView = new WebView{ Url = "mobile.twitter.com" };
var tp2 = new TabPage("Twitter");
tp2.Controls.Add(wc2);
tabControl1.TabPages.Add(tp2);
var wc3 = new WebControl { Dock = DockStyle.Fill, };
wc3.WebView = new WebView{ Url = "web.whatsapp.com" };
var tp3 = new TabPage("Whatsapp");
tp3.Controls.Add(wc3);
tabControl1.TabPages.Add(tp3);
wc.WebView.NewWindow += onNewWindow;
wc2.WebView.NewWindow += onNewWindow;
wc3.WebView.NewWindow += onNewWindow;
wc.WebView.StatusMessageChanged += onStatusMessageChanged;
wc2.WebView.StatusMessageChanged += onStatusMessageChanged;
wc3.WebView.StatusMessageChanged += onStatusMessageChanged;
wc.WebView.TitleChanged += onTitleChanged;
}
