public CorDebugProcess GetDeviceProcess(string deviceName, int eachSecondRetryMaxCount)
{
if (string.IsNullOrEmpty(deviceName))
{
throw new Exception("DebugPort.GetDeviceProcess() called with no argument");
}
MessageCentre.StartProgressMessage(String.Format(Resources.ResourceStrings.StartDeviceSearch, deviceName, eachSecondRetryMaxCount));
CorDebugProcess process = InternalGetDeviceProcess(deviceName);
if (process != null)
{
return(process);
}
if (eachSecondRetryMaxCount < 0)
{
eachSecondRetryMaxCount = 0;
}
for (int i = 0; i < eachSecondRetryMaxCount && process == null; i++)
{
System.Threading.Thread.Sleep(1000);
process = InternalGetDeviceProcess(deviceName);
}
MessageCentre.StopProgressMessage(String.Format((process == null)
? Resources.ResourceStrings.DeviceFound
: Resources.ResourceStrings.DeviceNotFound,
deviceName));
return(process);
}
/// <summary>
/// Handler for PingDeviceCommand
/// </summary>
/// <param name="sender"></param>
/// <param name="arguments"></param>
/// <remarks>OK to use async void because this is a top-level event-handler
/// https://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Tip-1-Async-void-is-for-top-level-event-handlers-only
/// </remarks>
private async void PingDeviceCommandHandler(object sender, EventArgs arguments)
{
// yield to give the UI thread a chance to respond to user input
await Task.Yield();
MessageCentre.StartProgressMessage($"Pinging {ViewModelLocator.DeviceExplorer.SelectedDevice.Description}...");
try
{
// disable the button
(sender as MenuCommand).Enabled = false;
// make sure this device is showing as selected in Device Explorer tree view
await ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
ViewModelLocator.DeviceExplorer.ForceNanoDeviceSelection();
});
// check if debugger engine exists
if (NanoDeviceCommService.Device.DebugEngine == null)
{
NanoDeviceCommService.Device.CreateDebugEngine();
}
// connect to the device
if (await NanoDeviceCommService.Device.DebugEngine.ConnectAsync(5000))
{
// ping device
var connection = NanoDeviceCommService.Device.Ping();
switch (ViewModelLocator.DeviceExplorer.SelectedDevice.DebugEngine.ConnectionSource)
{
case Tools.Debugger.WireProtocol.ConnectionSource.Unknown:
MessageCentre.OutputMessage($"No reply from {ViewModelLocator.DeviceExplorer.SelectedDevice.Description}");
break;
case Tools.Debugger.WireProtocol.ConnectionSource.nanoBooter:
case Tools.Debugger.WireProtocol.ConnectionSource.nanoCLR:
MessageCentre.OutputMessage($"{ViewModelLocator.DeviceExplorer.SelectedDevice.Description} is active running {ViewModelLocator.DeviceExplorer.SelectedDevice.DebugEngine.ConnectionSource.ToString()}");
break;
}
}
else
{
MessageCentre.OutputMessage($"{ViewModelLocator.DeviceExplorer.SelectedDevice.Description} is not responding, please reboot the device.");
}
}
catch (Exception ex)
{
}
finally
{
// enable the button
(sender as MenuCommand).Enabled = true;
MessageCentre.StopProgressMessage();
}
}
private void SaveButton_Click(object sender, System.Windows.RoutedEventArgs e)
{
// setup device network configuration block to save
var networkConfigurationToSave = (DataContext as DeviceExplorerViewModel).DeviceNetworkConfiguration;
// IPv4 address options
if (IPv4Automatic.IsChecked.GetValueOrDefault())
{
// IPv4 from DHCP
networkConfigurationToSave.StartupAddressMode = AddressMode.DHCP;
// clear remaining options
networkConfigurationToSave.IPv4Address = IPAddress.None;
networkConfigurationToSave.IPv4NetMask = IPAddress.None;
networkConfigurationToSave.IPv4GatewayAddress = IPAddress.None;
}
else
{
// IPv4 has static configuration
networkConfigurationToSave.StartupAddressMode = AddressMode.Static;
// clear remaining options
networkConfigurationToSave.IPv4Address = IPv4Address.GetAddress();
networkConfigurationToSave.IPv4NetMask = IPv4NetMask.GetAddress();
networkConfigurationToSave.IPv4GatewayAddress = IPv4GatewayAddress.GetAddress();
}
// IPv4 DNS options
if (IPv4DnsAutomatic.IsChecked.GetValueOrDefault())
{
// IPv4 DNS is automatic and provided by DHCP server
networkConfigurationToSave.AutomaticDNS = true;
// clear DNS addresses
networkConfigurationToSave.IPv4DNSAddress1 = IPAddress.None;
networkConfigurationToSave.IPv4DNSAddress2 = IPAddress.None;
}
else
{
// IPv4 DNS is static
networkConfigurationToSave.AutomaticDNS = false;
networkConfigurationToSave.IPv4DNSAddress1 = IPv4Dns1Address.GetAddress();
networkConfigurationToSave.IPv4DNSAddress2 = IPv4Dns2Address.GetAddress();
}
// IPv6 options are not being handled for now
// FIXME
networkConfigurationToSave.IPv6Address = IPAddress.None;
networkConfigurationToSave.IPv6NetMask = IPAddress.None;
networkConfigurationToSave.IPv6GatewayAddress = IPAddress.None;
networkConfigurationToSave.IPv6DNSAddress1 = IPAddress.None;
networkConfigurationToSave.IPv6DNSAddress2 = IPAddress.None;
// check MAC address
try
{
var newMACAddress = MACAddress.Text;
var newMACAddressArray = newMACAddress.Split(':');
var dummyMacAddress = newMACAddressArray.Select(a => byte.Parse(a, System.Globalization.NumberStyles.HexNumber)).ToArray();
}
catch (Exception ex)
{
// error parsing MAC address field
throw new Exception("Invalid MAC address format. Check value.");
}
// Wi-Fi config
(DataContext as DeviceExplorerViewModel).DeviceWireless80211Configuration.Password = WiFiPassword.Password;
MessageCentre.StartProgressMessage($"Uploading network configuration to {(DataContext as DeviceExplorerViewModel).SelectedDevice.Description}...");
// check if debugger engine exists
if ((DataContext as DeviceExplorerViewModel).SelectedDevice.DebugEngine == null)
{
(DataContext as DeviceExplorerViewModel).SelectedDevice.CreateDebugEngine();
}
// save network configuration to target
if ((DataContext as DeviceExplorerViewModel).SelectedDevice.DebugEngine.UpdateDeviceConfiguration(networkConfigurationToSave, 0))
{
if ((DataContext as DeviceExplorerViewModel).DeviceNetworkConfiguration.InterfaceType == NetworkInterfaceType.Wireless80211)
{
// save Wi-Fi profile to target
if ((DataContext as DeviceExplorerViewModel).SelectedDevice.DebugEngine.UpdateDeviceConfiguration((DataContext as DeviceExplorerViewModel).DeviceWireless80211Configuration, 0))
{
MessageCentre.OutputMessage($"{(DataContext as DeviceExplorerViewModel).SelectedDevice.Description} network configuration updated.");
MessageCentre.StopProgressMessage();
// close on success
Close();
}
}
else
{
// close on success
Close();
}
}
else
{
MessageCentre.OutputMessage($"Error updating {(DataContext as DeviceExplorerViewModel).SelectedDevice.Description} network configuration.");
MessageCentre.StopProgressMessage();
}
}
/// <summary>
/// Handler for NetworkConfigCommand
/// </summary>
/// <param name="sender"></param>
/// <param name="arguments"></param>
/// <remarks>OK to use async void because this is a top-level event-handler
/// https://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Tip-1-Async-void-is-for-top-level-event-handlers-only
/// </remarks>
private async void NetworkConfigCommandHandler(object sender, EventArgs arguments)
{
// yield to give the UI thread a chance to respond to user input
await Task.Yield();
try
{
// disable the button
(sender as MenuCommand).Enabled = false;
// make sure this device is showing as selected in Device Explorer tree view
await ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
ViewModelLocator.DeviceExplorer.ForceNanoDeviceSelection();
});
// check if debugger engine exists
if (NanoDeviceCommService.Device.DebugEngine == null)
{
NanoDeviceCommService.Device.CreateDebugEngine();
}
// connect to the device
if (await NanoDeviceCommService.Device.DebugEngine.ConnectAsync(5000))
{
try
{
// for now, just get the 1st network configuration, if exists
var networkConfigurations = NanoDeviceCommService.Device.DebugEngine.GetAllNetworkConfigurations();
if (networkConfigurations.Count > 0)
{
ViewModelLocator.DeviceExplorer.DeviceNetworkConfiguration = networkConfigurations[0];
}
else
{
ViewModelLocator.DeviceExplorer.DeviceNetworkConfiguration = new Debugger.DeviceConfiguration.NetworkConfigurationProperties();
}
// for now, just get the 1st Wi-Fi configuration, if exists
var wirellesConfigurations = NanoDeviceCommService.Device.DebugEngine.GetAllWireless80211Configurations();
if (wirellesConfigurations.Count > 0)
{
ViewModelLocator.DeviceExplorer.DeviceWireless80211Configuration = wirellesConfigurations[0];
}
else
{
ViewModelLocator.DeviceExplorer.DeviceWireless80211Configuration = new Debugger.DeviceConfiguration.Wireless80211ConfigurationProperties();
}
// yield to give the UI thread a chance to respond to user input
await Task.Yield();
// show network configuration dialogue
var networkConfigDialog = new NetworkConfigurationDialog();
networkConfigDialog.HasMinimizeButton = false;
networkConfigDialog.HasMaximizeButton = false;
networkConfigDialog.ShowModal();
}
catch
{
// report issue to user
MessageCentre.OutputMessage($"Error reading {ViewModelLocator.DeviceExplorer.SelectedDevice.Description} configurations.");
return;
}
}
else
{
MessageCentre.OutputMessage($"{ViewModelLocator.DeviceExplorer.SelectedDevice.Description} is not responding, please reboot the device.");
return;
}
}
catch (Exception ex)
{
}
finally
{
// enable the button
(sender as MenuCommand).Enabled = true;
// clear status bar
MessageCentre.StopProgressMessage();
}
}
/// <summary>
/// Handler for DeviceEraseCommand
/// </summary>
/// <param name="sender"></param>
/// <param name="arguments"></param>
/// <remarks>OK to use async void because this is a top-level event-handler
/// https://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Tip-1-Async-void-is-for-top-level-event-handlers-only
/// </remarks>
private async void DeviceEraseCommandHandler(object sender, EventArgs arguments)
{
// yield to give the UI thread a chance to respond to user input
await Task.Yield();
MessageCentre.StartProgressMessage($"Erasing {ViewModelLocator.DeviceExplorer.SelectedDevice.Description} deployment area...");
try
{
// disable the button
(sender as MenuCommand).Enabled = false;
// make sure this device is showing as selected in Device Explorer tree view
await ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
ViewModelLocator.DeviceExplorer.ForceNanoDeviceSelection();
});
// check if debugger engine exists
if (NanoDeviceCommService.Device.DebugEngine == null)
{
NanoDeviceCommService.Device.CreateDebugEngine();
}
// connect to the device
if (await NanoDeviceCommService.Device.DebugEngine.ConnectAsync(5000))
{
try
{
if (await NanoDeviceCommService.Device.EraseAsync(Debugger.EraseOptions.Deployment, CancellationToken.None))
{
MessageCentre.OutputMessage($"{ViewModelLocator.DeviceExplorer.SelectedDevice.Description} deployment area erased.");
// reset the hash for the connected device so the deployment information can be refreshed, if and when requested
ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash = 0;
// reboot device
NanoDeviceCommService.Device.DebugEngine.RebootDevice(Debugger.RebootOptions.ClrOnly | Debugger.RebootOptions.NoShutdown);
// yield to give the UI thread a chance to respond to user input
await Task.Yield();
}
else
{
// report issue to user
MessageCentre.OutputMessage($"Error erasing {ViewModelLocator.DeviceExplorer.SelectedDevice.Description} deployment area.");
}
}
catch
{
// report issue to user
MessageCentre.OutputMessage($"Error erasing {ViewModelLocator.DeviceExplorer.SelectedDevice.Description} deployment area.");
return;
}
}
else
{
// reset property to force that device capabilities are retrieved on next connection
ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash = 0;
MessageCentre.OutputMessage($"{ViewModelLocator.DeviceExplorer.SelectedDevice.Description} is not responding, please reboot the device.");
return;
}
}
catch (Exception ex)
{
}
finally
{
// enable the button
(sender as MenuCommand).Enabled = true;
// clear status bar
MessageCentre.StopProgressMessage();
}
}
/// <summary>
/// Handler for DeviceCapabilitiesCommand
/// </summary>
/// <param name="sender"></param>
/// <param name="arguments"></param>
/// <remarks>OK to use async void because this is a top-level event-handler
/// https://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Tip-1-Async-void-is-for-top-level-event-handlers-only
/// </remarks>
private async void DeviceCapabilitiesCommandHandler(object sender, EventArgs arguments)
{
// yield to give the UI thread a chance to respond to user input
await Task.Yield();
MessageCentre.StartProgressMessage($"Querying {ViewModelLocator.DeviceExplorer.SelectedDevice.Description} capabilities...");
try
{
// disable the button
(sender as MenuCommand).Enabled = false;
// make sure this device is showing as selected in Device Explorer tree view
await ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
ViewModelLocator.DeviceExplorer.ForceNanoDeviceSelection();
});
// only query device if it's different
if (ViewModelLocator.DeviceExplorer.SelectedDevice.Description.GetHashCode() != ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash)
{
// keep device description hash code to avoid get info twice
ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash = ViewModelLocator.DeviceExplorer.SelectedDevice.Description.GetHashCode();
// check if debugger engine exists
if (NanoDeviceCommService.Device.DebugEngine == null)
{
NanoDeviceCommService.Device.CreateDebugEngine();
}
// connect to the device
if (await NanoDeviceCommService.Device.DebugEngine.ConnectAsync(5000))
{
try
{
// get device info
var deviceInfo = NanoDeviceCommService.Device.GetDeviceInfo(true);
var memoryMap = NanoDeviceCommService.Device.DebugEngine.GetMemoryMap();
var flashMap = NanoDeviceCommService.Device.DebugEngine.GetFlashSectorMap();
var deploymentMap = NanoDeviceCommService.Device.DebugEngine.GetDeploymentMap();
// we have to have a valid device info
if (deviceInfo.Valid)
{
// load view model properties for maps
ViewModelLocator.DeviceExplorer.DeviceMemoryMap = new StringBuilder(memoryMap?.ToStringForOutput() ?? "Empty");
ViewModelLocator.DeviceExplorer.DeviceFlashSectorMap = new StringBuilder(flashMap?.ToStringForOutput() ?? "Empty");
ViewModelLocator.DeviceExplorer.DeviceDeploymentMap = new StringBuilder(deploymentMap?.ToStringForOutput() ?? "Empty");
// load view model property for system
ViewModelLocator.DeviceExplorer.DeviceSystemInfo = new StringBuilder(deviceInfo?.ToString() ?? "Empty");
}
else
{
// reset property to force that device capabilities are retrieved on next connection
ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash = 0;
// report issue to user
MessageCentre.OutputMessage($"Error retrieving device information from { ViewModelLocator.DeviceExplorer.SelectedDevice.Description}. Please reconnect device.");
return;
}
}
catch
{
// reset property to force that device capabilities are retrieved on next connection
ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash = 0;
// report issue to user
MessageCentre.OutputMessage($"Error retrieving device information from { ViewModelLocator.DeviceExplorer.SelectedDevice.Description}. Please reconnect device.");
return;
}
}
else
{
// reset property to force that device capabilities are retrieved on next connection
ViewModelLocator.DeviceExplorer.LastDeviceConnectedHash = 0;
MessageCentre.OutputMessage($"{ViewModelLocator.DeviceExplorer.SelectedDevice.Description} is not responding, please reboot the device.");
return;
}
}
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage("System Information");
MessageCentre.OutputMessage(ViewModelLocator.DeviceExplorer.DeviceSystemInfo.ToString());
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage("--------------------------------");
MessageCentre.OutputMessage(":: Memory Map ::");
MessageCentre.OutputMessage("--------------------------------");
MessageCentre.OutputMessage(ViewModelLocator.DeviceExplorer.DeviceMemoryMap.ToString());
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage("-----------------------------------------------------------");
MessageCentre.OutputMessage(":: Flash Sector Map ::");
MessageCentre.OutputMessage("-----------------------------------------------------------");
MessageCentre.OutputMessage(ViewModelLocator.DeviceExplorer.DeviceFlashSectorMap.ToString());
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage(string.Empty);
MessageCentre.OutputMessage("Deployment Map");
MessageCentre.OutputMessage(ViewModelLocator.DeviceExplorer.DeviceDeploymentMap.ToString());
MessageCentre.OutputMessage(string.Empty);
}
catch (Exception ex)
{
}
finally
{
// enable the button
(sender as MenuCommand).Enabled = true;
// clear status bar
MessageCentre.StopProgressMessage();
}
}
