/// <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>
/// 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>
/// 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.");
}
}
}
/// <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);
}
}
}
/// <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);
}
}
}
/// <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(AppUsageMessage);
return;
}
string operationType = parameters.GetParameterValue("subop");
if (string.IsNullOrWhiteSpace(operationType))
{
Console.WriteLine("Missing subop parameter");
Console.WriteLine();
Console.WriteLine(AppUsageMessage);
return;
}
operationType = operationType.ToLowerInvariant();
try
{
if (operationType.Equals("list"))
{
Task <AppPackages> packagesTask = portal.GetInstalledAppPackages();
packagesTask.Wait();
Console.WriteLine(packagesTask.Result);
}
else
{
string packageFullName = parameters.GetParameterValue("pfn");
if (string.IsNullOrEmpty(packageFullName))
{
Console.WriteLine("The Package Full Name is required as the /pfn<packageFullName> parameter for this operation.");
Console.WriteLine();
Console.WriteLine(AppUsageMessage);
return;
}
if (operationType.Equals("suspend"))
{
Console.WriteLine("Suspend isn't currently supported, but will be in the future.");
}
else if (operationType.Equals("resume"))
{
Console.WriteLine("Resume isn't currently supported, but will be in the future.");
}
else if (operationType.Equals("launch"))
{
string aumid = parameters.GetParameterValue("aumid");
if (string.IsNullOrEmpty(aumid))
{
Console.WriteLine("The appId (AUMID) is required as the /aumid:<appId> parameter for the launch operation.");
Console.WriteLine();
Console.WriteLine(AppUsageMessage);
return;
}
Task launchTask = portal.LaunchApplication(aumid, packageFullName);
launchTask.Wait();
Console.WriteLine("Application launched.");
}
else if (operationType.Equals("terminate"))
{
Task terminateTask = portal.TerminateApplication(packageFullName);
terminateTask.Wait();
Console.WriteLine("Application terminated.");
}
else if (operationType.Equals("uninstall"))
{
Task uninstallTask = portal.UninstallApplication(packageFullName);
uninstallTask.Wait();
Console.WriteLine("Application uninstalled.");
}
}
}
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>
/// Main entry point for handling a user 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(XblUserUsageMessage);
return;
}
string operationType = parameters.GetParameterValue("subop");
if (string.IsNullOrWhiteSpace(operationType))
{
Console.WriteLine("Missing subop parameter");
Console.WriteLine();
Console.WriteLine(XblUserUsageMessage);
return;
}
operationType = operationType.ToLowerInvariant();
if (operationType.Equals("list"))
{
Task <UserList> getUsers = portal.GetXboxLiveUsers();
getUsers.Wait();
Console.WriteLine(getUsers.Result);
}
else if (operationType.Equals("addsponsored"))
{
UserInfo user = new UserInfo();
user.SponsoredUser = true;
user.SignedIn = true;
UserList userList = new UserList();
userList.Add(user);
UpdateXboxLiveUsers(portal, userList);
}
else if (operationType.Equals("signin") || operationType.Equals("signout") || operationType.Equals("delete") || operationType.Equals("autosignin"))
{
UserInfo user = new UserInfo();
if (parameters.HasParameter("id"))
{
uint userId = 0;
if (!uint.TryParse(parameters.GetParameterValue("id"), out userId))
{
Console.WriteLine(string.Format("Failed to parse id to an unsigned integer: {0}", parameters.GetParameterValue("id")));
return;
}
user.UserId = userId;
}
else
{
user.EmailAddress = parameters.GetParameterValue("msa");
if (user.EmailAddress == null)
{
Console.WriteLine("Must provide either msa or id to this operation");
Console.WriteLine();
Console.WriteLine(XblUserUsageMessage);
return;
}
}
if (operationType.Equals("signin"))
{
// Optional password (only used on first signin)
user.Password = parameters.GetParameterValue("msapwd");
user.SignedIn = true;
}
else if (operationType.Equals("signout"))
{
user.SignedIn = false;
}
else if (operationType.Equals("delete"))
{
user.Delete = true;
}
else if (operationType.Equals("autosignin"))
{
if (parameters.HasFlag("on"))
{
user.AutoSignIn = true;
}
else if (parameters.HasFlag("off"))
{
user.AutoSignIn = false;
}
else
{
Console.WriteLine("autosignin operation requires the state (/on or /off).");
Console.WriteLine();
Console.WriteLine(XblUserUsageMessage);
return;
}
}
UserList userList = new UserList();
userList.Add(user);
UpdateXboxLiveUsers(portal, userList);
}
else
{
Console.WriteLine(string.Format("Unrecognized subop: {0}", operationType));
Console.WriteLine();
Console.WriteLine(XblUserUsageMessage);
return;
}
}
/// <summary>
/// Main entry point for handling an install 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(XblInstallUsageMessage);
return;
}
InstallOperation operation = new InstallOperation(portal);
portal.AppInstallStatus += operation.AppInstallStatusHandler;
if (parameters.HasFlag(ParameterHelper.VerboseFlag))
{
operation.verbose = true;
}
List <string> dependencies = new List <string>();
// Build up the list of dependencies.
if (parameters.HasParameter("depend"))
{
dependencies.AddRange(parameters.GetParameterValue("depend").Split(';'));
}
string certificate = parameters.GetParameterValue("cer");
string appxFile = parameters.GetParameterValue("appx");
string folderPath = parameters.GetParameterValue("folder");
string registerPath = parameters.GetParameterValue("register");
try
{
if (!string.IsNullOrEmpty(appxFile))
{
operation.mreAppInstall.Reset();
Task installTask = portal.InstallApplication(null, appxFile, dependencies, certificate);
operation.mreAppInstall.WaitOne();
if (operation.installResults.Status == ApplicationInstallStatus.Completed)
{
Console.WriteLine("Install complete.");
}
else
{
Console.WriteLine("Install failed in phase {0}. {1}", operation.installResults.Phase, operation.installResults.Message);
}
}
else if (!string.IsNullOrEmpty(folderPath))
{
// Install all dependencies one at a time (loose folder doesn't handle dependencies well).
foreach (string dependency in dependencies)
{
operation.mreAppInstall.Reset();
Task installTask = portal.InstallApplication(null, dependency, new List <string>());
operation.mreAppInstall.WaitOne();
if (operation.installResults.Status != ApplicationInstallStatus.Completed)
{
Console.WriteLine("Deploy failed during dependency installation. {0}", operation.installResults.Message);
return;
}
}
if (!Directory.Exists(folderPath))
{
Console.WriteLine("Failed to find provided loose folder.");
Console.WriteLine();
Console.WriteLine(XblInstallUsageMessage);
return;
}
// Remove any trailing slash
if (folderPath.EndsWith("\\"))
{
folderPath = folderPath.Remove(folderPath.Length - 1);
}
string destinationFolderName = parameters.GetParameterValue("destfoldername");
if (string.IsNullOrEmpty(destinationFolderName))
{
// Get just the folder name
string folderName = folderPath.Substring(folderPath.LastIndexOf('\\') + 1);
destinationFolderName = folderName;
}
string transferType = parameters.GetParameterValue("transfer");
if (string.IsNullOrEmpty(transferType) || string.Equals(transferType, "smb", StringComparison.OrdinalIgnoreCase))
{
string shareName = Path.Combine("\\\\", parameters.GetParameterValue(ParameterHelper.IpOrHostname), "DevelopmentFiles");
string destinationFolder = Path.Combine(shareName, "LooseApps", destinationFolderName);
try
{
operation.CopyDirectory(folderPath, destinationFolder);
}
catch (IOException e)
{
if (e.HResult == ErrorLogonFailureHresult)
{
Task <SmbInfo> smbTask = portal.GetSmbShareInfo();
smbTask.Wait();
// Set the username/password for accessing the share.
NetworkShare.DisconnectFromShare(shareName, true);
int connected = NetworkShare.ConnectToShare(shareName, smbTask.Result.Username, smbTask.Result.Password);
if (connected != 0)
{
Console.WriteLine(string.Format("Failed to connect to the network share: {0}", connected));
return;
}
operation.CopyDirectory(folderPath, destinationFolder);
NetworkShare.DisconnectFromShare(shareName, false);
}
else
{
Console.WriteLine(string.Format("Unexpected exception encountered: {0}", e.Message));
return;
}
}
}
else if (string.Equals(transferType, "http", StringComparison.OrdinalIgnoreCase))
{
operation.UploadDirectoryOverHttp(folderPath, destinationFolderName);
}
else
{
Console.WriteLine(string.Format("Unexpected transfer type received: {0}. Expecting one of SMB or HTTP.", transferType));
return;
}
Task registerTask = portal.RegisterApplication(destinationFolderName);
registerTask.Wait();
Console.WriteLine("Install complete.");
}
else if (!string.IsNullOrEmpty(registerPath))
{
Task registerTask = portal.RegisterApplication(registerPath);
registerTask.Wait();
Console.WriteLine("Registration complete.");
}
else
{
Console.WriteLine("Must provide an appx package, loose folder, or path to register.");
Console.WriteLine();
Console.WriteLine(XblInstallUsageMessage);
return;
}
}
catch (AggregateException e)
{
if (e.InnerException is DevicePortalException)
{
DevicePortalException innerException = e.InnerException as DevicePortalException;
Console.WriteLine(string.Format("Exception encountered: {0}, hr = 0x{1:X} : {2}", innerException.StatusCode, 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>
/// Main entry point for handling a Fiddler 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(FiddlerUsageMessage);
return;
}
string state = parameters.GetParameterValue("state");
if (string.IsNullOrEmpty(state))
{
Console.WriteLine("/state parameter is required.");
Console.WriteLine();
Console.WriteLine(FiddlerUsageMessage);
return;
}
try
{
if (string.Equals(state, "on", StringComparison.OrdinalIgnoreCase))
{
string proxyAddress = parameters.GetParameterValue("proxyaddress");
string proxyPort = parameters.GetParameterValue("proxyport");
if (string.IsNullOrEmpty(proxyAddress) || string.IsNullOrEmpty(proxyPort))
{
Console.WriteLine("/proxyaddress and /proxyport are required for enabling Fiddler.");
Console.WriteLine();
Console.WriteLine(FiddlerUsageMessage);
return;
}
Task fiddlerEnableTask = portal.EnableFiddlerTracing(proxyAddress, proxyPort, parameters.GetParameterValue("certpath"));
fiddlerEnableTask.Wait();
Console.WriteLine("Fiddler enabled.");
}
else if (string.Equals(state, "off", StringComparison.OrdinalIgnoreCase))
{
Task fiddlerDisableTask = portal.DisableFiddlerTracing();
fiddlerDisableTask.Wait();
Console.WriteLine("Fiddler disabled.");
}
else
{
Console.WriteLine("Unknown state parameter: {0}. Must be 'on' or 'off'.", state);
Console.WriteLine();
Console.WriteLine(FiddlerUsageMessage);
return;
}
if (parameters.HasFlag("reboot"))
{
Task rebootTask = portal.Reboot();
rebootTask.Wait();
Console.WriteLine("Console rebooting...");
}
else
{
Console.WriteLine("A reboot is required before this takes effect.");
}
}
catch (AggregateException e)
{
if (e.InnerException is DevicePortalException)
{
DevicePortalException innerException = e.InnerException as DevicePortalException;
Console.WriteLine(string.Format("Exception encountered: {0}, hr = 0x{1:X} : {2}", innerException.StatusCode, innerException.HResult, innerException.Reason));
}
else
{
Console.WriteLine(string.Format("Unexpected exception encountered: {0}", e.Message));
}
return;
}
}
/// <summary>
/// Main entry point for handling a Setting 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(XblFileUsageMessage);
return;
}
string operationType = parameters.GetParameterValue("subop");
if (string.IsNullOrWhiteSpace(operationType))
{
Console.WriteLine("Missing subop parameter");
Console.WriteLine();
Console.WriteLine(XblFileUsageMessage);
return;
}
operationType = operationType.ToLowerInvariant();
string knownFolderId = parameters.GetParameterValue("knownfolderid");
string subPath = parameters.GetParameterValue("subpath");
string packageFullName = parameters.GetParameterValue("packagefullname");
try
{
if (operationType.Equals("knownfolders"))
{
Task <KnownFolders> getKnownFoldersTask = portal.GetKnownFolders();
getKnownFoldersTask.Wait();
Console.WriteLine(getKnownFoldersTask.Result);
}
else
{
if (string.IsNullOrWhiteSpace(knownFolderId))
{
Console.WriteLine("Missing knownfolderid parameter");
Console.WriteLine();
Console.WriteLine(XblFileUsageMessage);
return;
}
if (operationType.Equals("dir"))
{
Task <FolderContents> getDirectoryContents = portal.GetFolderContents(knownFolderId, subPath, packageFullName);
getDirectoryContents.Wait();
Console.WriteLine(getDirectoryContents.Result);
}
else if (operationType.Equals("upload"))
{
string filepath = parameters.GetParameterValue("filepath");
if (string.IsNullOrWhiteSpace(filepath))
{
Console.WriteLine("Missing filepath parameter");
Console.WriteLine();
Console.WriteLine(XblFileUsageMessage);
return;
}
Task uploadFileTask = portal.UploadFile(knownFolderId, filepath, subPath, packageFullName);
uploadFileTask.Wait();
Console.WriteLine(string.Format("{0} uploaded.", filepath));
}
else
{
string filename = parameters.GetParameterValue("filename");
if (string.IsNullOrWhiteSpace(filename))
{
Console.WriteLine("Missing filename parameter");
Console.WriteLine();
Console.WriteLine(XblFileUsageMessage);
return;
}
if (operationType.Equals("download"))
{
string destination = parameters.GetParameterValue("destination");
if (string.IsNullOrWhiteSpace(destination))
{
Console.WriteLine("Missing destination parameter");
Console.WriteLine();
Console.WriteLine(XblFileUsageMessage);
return;
}
destination += "/" + filename;
Task <Stream> getFile = portal.GetFile(knownFolderId, filename, subPath, packageFullName);
getFile.Wait();
using (FileStream filestream = new FileStream(destination, FileMode.OpenOrCreate, FileAccess.Write))
{
getFile.Result.CopyTo(filestream);
}
Console.WriteLine(string.Format("Downloaded {0}.", destination));
}
else if (operationType.Equals("rename"))
{
string newfilename = parameters.GetParameterValue("newfilename");
if (string.IsNullOrWhiteSpace(newfilename))
{
Console.WriteLine("Missing newfilename parameter");
Console.WriteLine();
Console.WriteLine(XblFileUsageMessage);
return;
}
Task renameFileTask = portal.RenameFile(knownFolderId, filename, newfilename, subPath, packageFullName);
renameFileTask.Wait();
Console.WriteLine(string.Format("Renamed {0} to {1}.", filename, newfilename));
}
else if (operationType.Equals("delete"))
{
Task deleteFileTask = portal.DeleteFile(knownFolderId, filename, subPath, packageFullName);
deleteFileTask.Wait();
Console.WriteLine(string.Format("Deleted {0}.", filename));
}
}
}
}
catch (AggregateException e)
{
if (e.InnerException != null && e.InnerException is DevicePortalException)
{
DevicePortalException exception = e.InnerException as DevicePortalException;
Console.WriteLine(string.Format("HTTP Status: {0}, Hresult: 0x{1:X8}. {2}", exception.StatusCode, exception.HResult, exception.Reason));
}
}
}