/// <summary> /// Connects to a HoloLens using the provided credentials. /// </summary> /// <param name="userName"></param> /// <param name="password"></param> /// <returns></returns> public async Task ConnectAsync( string address, string userName, string password) { this.devicePortalConnection = new HoloLensDevicePortalConnection( address, userName, password); DevicePortal portal = new DevicePortal(this.devicePortalConnection); portal.ConnectionStatus += DevicePortal_ConnectionStatus; // We are physically connected to the device. // We can safely accept the device's root certificate. Certificate certificate = await portal.GetRootDeviceCertificateAsync(true); // Establish the connection to the device. // TODO: Add support for optionally setting the SSID and key. await portal.ConnectAsync( null, null, updateConnection : true, manualCertificate : certificate); }
/// <summary> /// Validate the server certificate /// </summary> /// <param name="sender">The sender object</param> /// <param name="certificate">The server's certificate</param> /// <param name="chain">The cert chain</param> /// <param name="sslPolicyErrors">Policy Errors</param> /// <returns>whether the cert passes validation</returns> private bool DoCertValidation(DevicePortal sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { X509Certificate2 cert = new X509Certificate2(certificate); // If we have previously said to accept this cert, don't prompt again for this session. if (!string.IsNullOrEmpty(this.thumbprint) && this.thumbprint.Equals(cert.Thumbprint, StringComparison.OrdinalIgnoreCase)) { return(true); } // We could alternatively ask the user if they wanted to always trust // this device and we could persist the thumbprint in some way (registry, database, filesystem, etc). MessageBoxResult result = MessageBox.Show(string.Format( "Do you want to accept the following certificate?\n\nThumbprint:\n {0}\nIssuer:\n {1}", cert.Thumbprint, cert.Issuer), "Untrusted Certificate Detected", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No); if (result == MessageBoxResult.Yes) { thumbprint = cert.Thumbprint; return(true); } return(false); }
private async Task <bool> TryAuthenticateAsync() { try { // Create portal object portal = new DevicePortal( new DefaultDevicePortalConnection( "https://127.0.0.1", UserNameBox.Text, PasswordBox.Password)); // Get cert (OK to use untrusted since it's loopback) await portal.GetRootDeviceCertificate(acceptUntrustedCerts : true); // Attempt to connect await portal.Connect(); // Get IPD var ipd = await portal.GetInterPupilaryDistance(); // Success! return(true); } catch (Exception) { // Problem await new MessageDialog("Authentication was not successful. Please make sure Device Portal is enabled and check your password.", "Error").ShowAsync(); return(false); } }
private async Task <bool> TryAuthenticateAsync() { try { // Create portal object var portal = new DevicePortal( new DefaultDevicePortalConnection( "https://127.0.0.1", UserNameBox.Text, PasswordBox.Password)); // Attempt to connect await portal.Connect(); // Get IPD var ipd = await portal.GetInterPupilaryDistance(); // Success! return(true); } catch (Exception ex) { // Problem await new MessageDialog(ex.Message, "Error").ShowAsync(); return(false); } }
/// <summary> /// Helper to make the REST call and handle exceptions. /// </summary> /// <param name="portal">DevicePortal reference for communicating with the device.</param> /// <param name="userList">UserList object for updating the remote device.</param> private static void UpdateXboxLiveUsers(DevicePortal portal, UserList userList) { try { Task updateUsers = portal.UpdateXboxLiveUsers(userList); updateUsers.Wait(); } catch (AggregateException e) { if (e.InnerException is DevicePortalException) { DevicePortalException innerException = e.InnerException as DevicePortalException; Console.WriteLine(string.Format("Exception encountered: 0x{0:X} : {1}", innerException.HResult, innerException.Reason)); } else if (e.InnerException is OperationCanceledException) { Console.WriteLine("The operation was cancelled."); } else { Console.WriteLine(string.Format("Unexpected exception encountered: {0}", e.Message)); } return; } }
/// <summary> /// Connects to a HoloLens using the provided credentials. /// </summary> /// <param name="userName"></param> /// <param name="password"></param> /// <returns></returns> public async Task ConnectAsync( string address, string userName, string password) { this.devicePortalConnection = new HoloLensDevicePortalConnection( address, userName, password); DevicePortal portal = new DevicePortal(this.devicePortalConnection); portal.ConnectionStatus += DevicePortal_ConnectionStatus; // If the address is localhost (127.0.0.1), we are physically connected // to the HoloLens. This allows us to implicitly trust the device // certificate. // // !! NOTE: UWP applications are not allowed to connect to localhost // unless explicitly configured. // * Development - Visual Studio performs this configuration automatically. // * Side-loading - Please see README.md for more details. // * Store submissions - Use only non-loopback connections. Certificate certificate = await portal.GetRootDeviceCertificateAsync(true); // Establish the connection to the device. // TODO: Add support for optionally setting the SSID and key. await portal.ConnectAsync( null, null, updateConnection : true, manualCertificate : certificate); }
/// <summary> /// Handles the ConnectionStatus event. /// </summary> /// <param name="sender">The object which sent this event.</param> /// <param name="args">Event arguments.</param> private void DevicePortal_ConnectionStatus( DevicePortal sender, DeviceConnectionStatusEventArgs args) { if (args.Status == DeviceConnectionStatus.Connected) { // Connection successfully established. this.firstContact = true; this.devicePortal = sender; this.devicePortal.AppInstallStatus += DevicePortal_AppInstallStatus; this.devicePortal.ConnectionStatus -= DevicePortal_ConnectionStatus; if (this.connectOptions.DeployNameToDevice) { Task.Run( async() => { if (await this.SetDeviceNameAsync(this.connectOptions.Name)) { await this.RebootAsync(); } }); } } else if (args.Status == DeviceConnectionStatus.Failed) { // Connection failed. this.firstContact = false; this.devicePortal.ConnectionStatus -= DevicePortal_ConnectionStatus; throw new Exception(args.Message); } }
public async Task <bool> Initialize(bool promptCredentials = false) { var result = true; if (promptCredentials) { result = (bool)PromptForCredentials(); } if (!result) { return(false); } Portal = new DevicePortal( new DefaultDevicePortalConnection( ipAddress, username, password)); await Portal.Connect(null, null, autoDetectIP); ipAddress = Portal.Address; return(true); }
static async public Task SetXboxLiveSandboxAsync(string url, string sandbox, string userName = null, string password = null) { DevicePortal connection = GetConnection(url, userName, password); await connection.SetXboxLiveSandboxAsync(sandbox); await connection.RebootAsync(); }
/// <summary> /// Main entry point for handling a Screenshot operation /// </summary> /// <param name="portal">DevicePortal reference for communicating with the device.</param> /// <param name="parameters">Parsed command line parameters.</param> public static void HandleOperation(DevicePortal portal, ParameterHelper parameters) { if (parameters.HasFlag(ParameterHelper.HelpFlag)) { Console.WriteLine(XblScreenshotUsageMessage); return; } string filepath = parameters.GetParameterValue("filepath"); if (string.IsNullOrEmpty(filepath)) { filepath = "xbox_screenshot.png"; } if (File.Exists(filepath) && !parameters.HasFlag("override")) { Console.WriteLine("Found an existing file: {0}. Specify /override flag to override this file.", filepath); } else { Task <Stream> screenshotTask = portal.TakeXboxScreenshotAsync(); screenshotTask.Wait(); using (var fileStream = new FileStream(filepath, FileMode.Create)) { screenshotTask.Result.CopyTo(fileStream); } Console.WriteLine("Screenshot saved as {0}.", filepath); } }
/// <summary> /// Click handler for the connectToDevice button. /// </summary> /// <param name="sender">The caller of this method.</param> /// <param name="e">The arguments associated with this event.</param> private void ConnectToDevice_Click(object sender, RoutedEventArgs e) { this.EnableConnectionControls(false); this.EnableDeviceControls(false); this.ClearOutput(); portal = new DevicePortal( new DefaultDevicePortalConnection( this.address.Text, this.username.Text, this.password.Password)); // Add additional handling for untrusted certs. portal.UnvalidatedCert += DoCertValidation; StringBuilder sb = new StringBuilder(); Task connectTask = new Task( async() => { sb.Append(this.MarshalGetCommandOutput()); sb.AppendLine("Connecting..."); this.MarshalUpdateCommandOutput(sb.ToString()); portal.ConnectionStatus += (portal, connectArgs) => { if (connectArgs.Status == DeviceConnectionStatus.Connected) { sb.Append("Connected to: "); sb.AppendLine(portal.Address); sb.Append("OS version: "); sb.AppendLine(portal.OperatingSystemVersion); sb.Append("Device family: "); sb.AppendLine(portal.DeviceFamily); sb.Append("Platform: "); sb.AppendLine(String.Format("{0} ({1})", portal.PlatformName, portal.Platform.ToString())); } else if (connectArgs.Status == DeviceConnectionStatus.Failed) { sb.AppendLine("Failed to connect to the device."); sb.AppendLine(connectArgs.Message); } }; await portal.ConnectAsync(); this.MarshalUpdateCommandOutput(sb.ToString()); }); Task continuationTask = connectTask.ContinueWith( (t) => { this.MarshalEnableDeviceControls(true); this.MarshalEnableConnectionControls(true); }); connectTask.Start(); }
public AppOperation(DevicePortal portal) { if (portal == null) { throw new System.ArgumentNullException("Must specify a valid DevicePortal object"); } _portal = portal; _runningOperation = new SemaphoreSlim(1, 1); }
private async Task <bool> AuthSilentAsync() { // Placeholder PasswordCredential cred = null; // Try to get user name and password try { cred = vault.FindAllByResource(PortalResourceName).FirstOrDefault(); // Password does not come across with the method above. We must call another method. if (cred != null) { cred = vault.Retrieve(PortalResourceName, cred.UserName); } } catch { } // If no credentials were found, fail if (cred == null) { return(false); } // Credentials found. Try and log into portal try { // Create portal object portal = new DevicePortal( new DefaultDevicePortalConnection( "https://127.0.0.1", cred.UserName, cred.Password)); // Get cert (OK to use untrusted since it's loopback) await portal.GetRootDeviceCertificate(acceptUntrustedCerts : true); // Attempt to connect await portal.Connect(); // Get IPD var ipd = await portal.GetInterPupilaryDistance(); // Success! return(true); } catch (Exception ex) { // Problem ShowError(ex.Message); return(false); } }
public static bool TryExecuteApplicationOperation(DevicePortal portal, ParameterHelper parameters) { try { var appOperation = new AppOperation(portal); appOperation.ExecuteOperation(AppOperation.OperationStringToEnum(parameters.GetParameterValue(ParameterHelper.Operation)), parameters); } catch (Exception) { return(false); } return(true); }
private void DevicePortalConnectionStatus(DevicePortal sender, DeviceConnectionStatusEventArgs args) { // This can get called back on random threads. Marshal it back to the UI thread if needed if (MainThread.IsMainThread) { this.DeviceConnectionStatus = args.Status; } else { // Not clear if this is the right thing to do in the Xamarin world using TPL MainThread.BeginInvokeOnMainThread(() => { this.DevicePortalConnectionStatus(sender, args); }); } }
/// <summary> /// Main entry point for handling a System Perf operation /// </summary> /// <param name="portal">DevicePortal reference for communicating with the device.</param> /// <param name="parameters">Parsed command line parameters.</param> public static void HandleOperation(DevicePortal portal, ParameterHelper parameters) { SystemPerformanceInformation systemPerformanceInformation = null; if (parameters.HasFlag(ParameterHelper.Listen)) { ManualResetEvent systemPerfReceived = new ManualResetEvent(false); WebSocketMessageReceivedEventHandler <SystemPerformanceInformation> systemPerfReceivedHandler = delegate(DevicePortal sender, WebSocketMessageReceivedEventArgs <SystemPerformanceInformation> sysPerfInfoArgs) { if (sysPerfInfoArgs.Message != null) { systemPerformanceInformation = sysPerfInfoArgs.Message; systemPerfReceived.Set(); } }; portal.SystemPerfMessageReceived += systemPerfReceivedHandler; Task startListeningForSystemPerfTask = portal.StartListeningForSystemPerf(); startListeningForSystemPerfTask.Wait(); systemPerfReceived.WaitOne(); Task stopListeningForSystemPerfTask = portal.StopListeningForRunningProcesses(); stopListeningForSystemPerfTask.Wait(); portal.SystemPerfMessageReceived -= systemPerfReceivedHandler; } else { Task <SystemPerformanceInformation> getRunningProcessesTask = portal.GetSystemPerf(); systemPerformanceInformation = getRunningProcessesTask.Result; } Console.WriteLine("Available Pages: " + systemPerformanceInformation.AvailablePages); Console.WriteLine("Commit Limit: " + systemPerformanceInformation.CommitLimit); Console.WriteLine("Commited Pages: " + systemPerformanceInformation.CommittedPages); Console.WriteLine("CPU Load: " + systemPerformanceInformation.CpuLoad); Console.WriteLine("IoOther Speed: " + systemPerformanceInformation.IoOtherSpeed); Console.WriteLine("IoRead Speed: " + systemPerformanceInformation.IoReadSpeed); Console.WriteLine("IoWrite Speed: " + systemPerformanceInformation.IoWriteSpeed); Console.WriteLine("Non-paged Pool Pages: " + systemPerformanceInformation.NonPagedPoolPages); Console.WriteLine("Paged Pool Pages: " + systemPerformanceInformation.PagedPoolPages); Console.WriteLine("Page Size: " + systemPerformanceInformation.PageSize); Console.WriteLine("Total Installed Kb: " + systemPerformanceInformation.TotalInstalledKb); Console.WriteLine("Total Pages: " + systemPerformanceInformation.TotalPages); }
/// <summary> /// Cleans up encapsulated resources. /// </summary> public void Dispose() { if (this.devicePortal != null) { this.devicePortal.AppInstallStatus += DevicePortal_AppInstallStatus; this.devicePortal = null; } // Release the resources we manage. this.heartbeatTimer?.Dispose(); this.heartbeatTimer = null; // Suppress finalization to avoid attempting to clean up twice. GC.SuppressFinalize(this); }
/// <summary> /// TextChanged handler for the address text box. /// </summary> /// <param name="sender">The caller of this method.</param> /// <param name="e">The arguments associated with this event.</param> private async void btnTakePicture2_Click(object sender, RoutedEventArgs e) { portal = new DevicePortal( new DefaultDevicePortalConnection(HoloLensUrl, "Tolegen", "*****")); StringBuilder sb = new StringBuilder(); sb.Append(this.messageb.Text); sb.AppendLine("Connecting..."); this.messageb.Text = sb.ToString(); portal.ConnectionStatus += (portal, connectArgs) => { if (connectArgs.Status == DeviceConnectionStatus.Connected) { sb.Append("Connected to: "); sb.AppendLine(portal.Address); sb.Append("OS version: "); sb.AppendLine(portal.OperatingSystemVersion); sb.Append("Device family: "); sb.AppendLine(portal.DeviceFamily); sb.Append("Platform: "); sb.AppendLine(String.Format("{0} ({1})", portal.PlatformName, portal.Platform.ToString())); } else if (connectArgs.Status == DeviceConnectionStatus.Failed) { sb.AppendLine("Failed to connect to the device."); sb.AppendLine(connectArgs.Message); } }; try { // If the user wants to allow untrusted connections, make a call to GetRootDeviceCertificate // with acceptUntrustedCerts set to true. This will enable untrusted connections for the // remainder of this session. this.certificate = await portal.GetRootDeviceCertificateAsync(true); await portal.ConnectAsync(manualCertificate : this.certificate); } catch (Exception exception) { sb.AppendLine(exception.Message); } this.messageb.Text = sb.ToString(); }
/// <summary> /// Makes sure there is a connection to the device. If device can't be contacted /// it will throw. Does not try to ping the device. /// </summary> /// <returns></returns> /// <remarks>Note that we let exceptions leave this function. We depend on caller for any retry</remarks> private async Task EnsureConnectionAsync() { // Make sure we're not trying multiple connections. // This logic assumes one thread. There will be a race condition // with the isConnecting field if multiple threads are executing this. if (this.isConnecting) { // we're already trying to connect on another task. Wait await WaitForCondition(TimeSpan.FromSeconds(2.0), new CancellationToken(), () => !this.isConnecting); // TODO: maybe make this timeout configurable } this.isConnecting = true; try { if (this.devicePortalConnection == null) { var address = FixupMachineAddress(this.Address, false); this.devicePortalConnection = new DefaultDevicePortalConnection( address, this.UserName, this.Password); this.devicePortal = new DevicePortal(this.devicePortalConnection); this.devicePortal.UnvalidatedCert += (sender, certificate, chain, sslPolicyErrors) => true; // Allow unvalidated certs this.devicePortal.ConnectionStatus += DevicePortalConnectionStatus; } if (this.DeviceConnectionStatus != DeviceConnectionStatus.Connected || this.DeviceConnectionStatus != DeviceConnectionStatus.Connecting) { X509Certificate2 certificate = await this.devicePortal.GetRootDeviceCertificateAsync(); // Establish the connection to the device. await this.devicePortal.ConnectAsync( ssid : null, ssidKey : null, updateConnection : false, manualCertificate : certificate); } } finally { this.isConnecting = false; } }
public void ContinueAuthFromLogin(DevicePortal portal) { // Overwrite portal variable with the one passed to us from auth window this.portal = portal; // If we have a valid portal we're signed in if (portal != null) { State = FBControllerState.LoggedIn; } else { State = FBControllerState.LoggedOut; } // Auth view has been closed. Continue auth state machine. AuthStateMachine(); }
static private DevicePortal GetConnection(string url, string userName, string password) { DevicePortal connection = connections.GetOrAdd(url, (key) => { var newConnection = new DevicePortal(new DefaultDevicePortalConnection(key, userName, password)); newConnection.UnvalidatedCert += Connection_UnvalidatedCert; newConnection.ConnectAsync().Wait(); if (newConnection.ConnectionHttpStatusCode != HttpStatusCode.OK) { throw new DevicePortalException(newConnection.ConnectionHttpStatusCode, "Failed to connect to windows develop portal: " + newConnection.ConnectionFailedDescription); } return(newConnection); }); return(connection); }
/// <summary> /// Main entry point for handling listing processes /// </summary> /// <param name="portal">DevicePortal reference for communicating with the device.</param> /// <param name="parameters">Parsed command line parameters.</param> public static void HandleOperation(DevicePortal portal, ParameterHelper parameters) { RunningProcesses runningProcesses = null; if (parameters.HasFlag(ParameterHelper.Listen)) { ManualResetEvent runningProcessesReceived = new ManualResetEvent(false); WebSocketMessageReceivedEventHandler <RunningProcesses> runningProcessesReceivedHandler = delegate(DevicePortal sender, WebSocketMessageReceivedEventArgs <RunningProcesses> runningProccesesArgs) { if (runningProccesesArgs.Message != null) { runningProcesses = runningProccesesArgs.Message; runningProcessesReceived.Set(); } }; portal.RunningProcessesMessageReceived += runningProcessesReceivedHandler; Task startListeningForProcessesTask = portal.StartListeningForRunningProcesses(); startListeningForProcessesTask.Wait(); runningProcessesReceived.WaitOne(); Task stopListeningForProcessesTask = portal.StopListeningForRunningProcesses(); stopListeningForProcessesTask.Wait(); portal.RunningProcessesMessageReceived -= runningProcessesReceivedHandler; } else { Task <DevicePortal.RunningProcesses> getRunningProcessesTask = portal.GetRunningProcesses(); runningProcesses = getRunningProcessesTask.Result; } foreach (DeviceProcessInfo process in runningProcesses.Processes) { if (!string.IsNullOrEmpty(process.Name)) { Console.WriteLine(process.Name); } } }
private static bool TryOpenDevicePortalConnection(Uri targetDevice, ParameterHelper parameters, out DevicePortal portal) { string userName = parameters.GetParameterValue(ParameterHelper.WdpUser); string password = parameters.GetParameterValue(ParameterHelper.WdpPassword); bool success = true; portal = new DevicePortal(new DefaultDevicePortalConnection(targetDevice.ToString(), userName, password)); try { // We need to handle this event otherwise remote connection will be rejected if // device isn't trusted by local PC portal.UnvalidatedCert += DoCertValidation; var connectTask = portal.ConnectAsync(updateConnection: false); connectTask.Wait(); if (portal.ConnectionHttpStatusCode != System.Net.HttpStatusCode.OK) { if (portal.ConnectionHttpStatusCode == System.Net.HttpStatusCode.Unauthorized) { throw new System.UnauthorizedAccessException("Connection rejected due to missing/incorrect credentials; specify valid credentials with /user and /pwd switches"); } else if (!string.IsNullOrEmpty(portal.ConnectionFailedDescription)) { throw new System.OperationCanceledException(string.Format("WDP connection failed (HTTP {0}) : {1}", (int)portal.ConnectionHttpStatusCode, portal.ConnectionFailedDescription)); } else { throw new System.OperationCanceledException(string.Format("WDP connection failed (HTTP {0}) : no additional information", (int)portal.ConnectionHttpStatusCode)); } } } catch (Exception ex) { bool verbose = parameters.HasFlag(ParameterHelper.VerboseFlag); Console.Out.WriteLine("Failed to open DevicePortal connection to '" + portal.Address + "'\n" + (verbose ? ex.ToString() : ex.Message)); success = false; } return(success); }
/// <summary> /// Main entry point for handling a Config operation /// </summary> /// <param name="portal">DevicePortal reference for communicating with the device.</param> /// <param name="parameters">Parsed command line parameters.</param> public static void HandleOperation(DevicePortal portal, ParameterHelper parameters) { if (parameters.HasFlag(ParameterHelper.HelpFlag)) { Console.WriteLine(ConfigUsageMessage); return; } string desiredSetting = parameters.GetParameterValue("setting"); string desiredValue = parameters.GetParameterValue("value"); // Determine if this is for all settings or a single setting. if (string.IsNullOrWhiteSpace(desiredSetting)) { Task <XboxSettingList> getSettingsTask = portal.GetXboxSettings(); getSettingsTask.Wait(); Console.WriteLine(getSettingsTask.Result); } else { if (string.IsNullOrWhiteSpace(desiredValue)) { Task <XboxSetting> getSettingTask = portal.GetXboxSetting(desiredSetting); getSettingTask.Wait(); Console.WriteLine(getSettingTask.Result); } else { XboxSetting setting = new XboxSetting(); setting.Name = desiredSetting; setting.Value = desiredValue; Task <XboxSetting> setSettingTask = portal.UpdateXboxSetting(setting); setSettingTask.Wait(); Console.WriteLine(setSettingTask.Result); } } }
public async Task ConnectAsync() { if (_devicePortal != null) { _devicePortal.ConnectionStatus -= DevicePortal_ConnectionStatus; } // 入力された情報をもとに接続 _devicePortal = new DevicePortal(new DefaultDevicePortalConnection(Address, UserName, Password)); _devicePortal.ConnectionStatus += DevicePortal_ConnectionStatus; try { // 証明書をデバイスポータルから取得して、それを使って接続を行う await _devicePortal.ConnectAsync(manualCertificate : await _devicePortal.GetRootDeviceCertificateAsync(true)); } catch (Exception ex) { Message = ex.Message; Debug.WriteLine(ex); } }
/// <summary> /// Connects to a device. /// </summary> /// <param name="connectOptions">Options that specify how the connection is to be established.</param> /// <returns></returns> public async Task ConnectAsync( ConnectOptions connectOptions) { string address = connectOptions.Address.ToLower(); if (!address.StartsWith("http")) { string scheme = "https"; if ((address == DefaultConnectionAddress) || (address == DefaultConnectionAddressAsIp)) { scheme = "http"; } address = string.Format( "{0}://{1}", scheme, address); } this.devicePortalConnection = new DefaultDevicePortalConnection( address, connectOptions.UserName, connectOptions.Password); DevicePortal portal = new DevicePortal(this.devicePortalConnection); portal.ConnectionStatus += DevicePortal_ConnectionStatus; // We are physically connected to the device. // We can safely accept the device's root certificate. Certificate certificate = await portal.GetRootDeviceCertificateAsync(true); // Establish the connection to the device. await portal.ConnectAsync( connectOptions.Ssid, connectOptions.NetworkKey, updateConnection : connectOptions.UpdateConnection, manualCertificate : certificate); }
/// <summary> /// Validate the server certificate /// </summary> /// <param name="sender">The sender object</param> /// <param name="certificate">The server's certificate</param> /// <param name="chain">The cert chain</param> /// <param name="sslPolicyErrors">Policy Errors</param> /// <returns>whether the cert passes validation</returns> private bool DoCertValidation(DevicePortal sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { X509Certificate2 cert = new X509Certificate2(certificate); if (!string.IsNullOrEmpty(this.AcceptedThumbprint)) { if (cert.Thumbprint.Equals(this.AcceptedThumbprint, StringComparison.OrdinalIgnoreCase)) { return(true); } } Console.WriteLine("The certificate provided by the device failed validation."); Console.WriteLine("Issuer:\t\t{0}", cert.Issuer); Console.WriteLine("Thumbprint:\t{0}", cert.Thumbprint); Console.WriteLine(); Console.WriteLine("If you trust this endpoint, you can manually specify this certificate should be accepted by adding the following to any call:\n\t/thumbprint:{0}", cert.Thumbprint); Console.WriteLine("Or you can permanently add this as a trusted certificate for this device by calling the following:\n\tXboxWdpDriver.exe /op:connect /thumbprint:{0}", cert.Thumbprint); Console.WriteLine(); return(false); }
/// <summary> /// Handles the ConnectionStatus event. /// </summary> /// <param name="sender">The object which sent this event.</param> /// <param name="args">Event arguments.</param> private void DevicePortal_ConnectionStatus( DevicePortal sender, DeviceConnectionStatusEventArgs args) { if (args.Status == DeviceConnectionStatus.Connected) { // Connection successfully established. this.devicePortal = sender; this.devicePortal.AppInstallStatus += DevicePortal_AppInstallStatus; // Start the heartbeat. Task t = CheckHeartbeatAsync(); t.Wait(); this.devicePortal.ConnectionStatus -= DevicePortal_ConnectionStatus; } else if (args.Status == DeviceConnectionStatus.Failed) { this.devicePortal.ConnectionStatus -= DevicePortal_ConnectionStatus; // Connection failed. throw new Exception(args.Message); } }
/// <summary> /// Main entry point for handling a Sandbox operation /// </summary> /// <param name="portal">DevicePortal reference for communicating with the device.</param> /// <param name="parameters">Parsed command line parameters.</param> public static void HandleOperation(DevicePortal portal, ParameterHelper parameters) { if (parameters.HasFlag(ParameterHelper.HelpFlag)) { Console.WriteLine(SandboxUsageMessage); return; } string desiredValue = parameters.GetParameterValue("value"); if (string.IsNullOrEmpty(desiredValue)) { Task <Sandbox> getSandboxTask = portal.GetXboxLiveSandbox(); getSandboxTask.Wait(); Console.WriteLine(getSandboxTask.Result); } else { Task <Sandbox> setSandboxTask = portal.SetXboxLiveSandbox(desiredValue); setSandboxTask.Wait(); Console.WriteLine("{0} -> {1}", setSandboxTask.Result, desiredValue); if (parameters.HasFlag("reboot")) { Task rebootTask = portal.Reboot(); rebootTask.Wait(); Console.WriteLine("Console rebooting..."); } else { Console.WriteLine("A reboot is required before this setting takes effect."); } } }
private void DevicePortal_AppInstallStatus( DevicePortal sender, ApplicationInstallStatusEventArgs args) { NotifyAppInstallStatus(args); }