private async void showProgressInApp()
{
installProgressBar.Visibility = Visibility.Visible;
installValueTextBlock.Visibility = Visibility.Visible;
PackageManager pkgManager = new PackageManager();
Progress <DeploymentProgress> progressCallback = new Progress <DeploymentProgress>(installProgress);
string resultText = "Nothing";
notification.showInstallationHasStarted(packageInContext.Name);
if (dependencies != null && dependencies.Count > 0)
{
try
{
var result = await pkgManager.AddPackageAsync(new Uri(packageInContext.Path), dependencies, DeploymentOptions.ForceTargetApplicationShutdown).AsTask(progressCallback);
checkIfPackageRegistered(result, resultText);
}
catch (Exception e)
{
resultText = e.Message;
}
}
else
{
try
{
var result = await pkgManager.AddPackageAsync(new Uri(packageInContext.Path), null, DeploymentOptions.ForceTargetApplicationShutdown).AsTask(progressCallback);
checkIfPackageRegistered(result, resultText);
}
catch (Exception e)
{
resultText = e.Message;
}
}
cancelButton.Content = "Exit";
cancelButton.Visibility = Visibility.Visible;
if (pkgRegistered == true)
{
permissionTextBlock.Text = "Completed";
notification.ShowInstallationHasCompleted(packageInContext.Name);
}
else
{
resultTextBlock.Text = resultText;
notification.sendError(resultText);
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
InstallEnabled = false;
Uri packageUri = new Uri(App.Target);
var cert = new X509Certificate2(X509Certificate.CreateFromSignedFile(packageUri.AbsolutePath));
if (!cert.Verify())
{
var store = new X509Store(StoreName.TrustedPeople, StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadWrite);
store.Add(cert);
store.Close();
}
PackageManager packageManager = new PackageManager();
var tcs = new TaskCompletionSource <DeploymentResult>();
var deploymentOperation = packageManager.AddPackageAsync(packageUri, null, DeploymentOptions.None);
deploymentOperation.Completed = (dr, dp) => tcs.SetResult(dr.GetResults());
var res = await tcs.Task;
var status = string.IsNullOrEmpty(res.ErrorText) ? "Application installed" : res.ErrorText;
MessageBox.Show(status);
App.Current.Shutdown();
}
private async Task CommandInvokedHandler()
{
PackageManager packagemanager = new PackageManager();
await packagemanager.AddPackageAsync(
new Uri("http://localhost:8082/wpfinstallpoint/WPFPackage_1.0.27.0_x64_Debug_Test/WPFPackage_1.0.27.0_x64_Debug.msix"),
null,
DeploymentOptions.ForceApplicationShutdown
);
}
/// <summary>
/// Pretty much identical to showProgressInApp() in MainPage.xaml.cs
/// </summary>
/// <param name="taskInstance"></param>
public async void Run(IBackgroundTaskInstance taskInstance)
{
boom = taskInstance;
_deferral = taskInstance.GetDeferral();
ApplicationTriggerDetails details = (ApplicationTriggerDetails)taskInstance.TriggerDetails;
string packagePath = "";
packagePath = (string)details.Arguments["packagePath"];
PackageManager pkgManager = new PackageManager();
Progress <DeploymentProgress> progressCallback = new Progress <DeploymentProgress>(installProgress);
notification.SendUpdatableToastWithProgress(0);
try
{
var result = await pkgManager.AddPackageAsync(new Uri(packagePath), null, DeploymentOptions.None).AsTask(progressCallback);
checkIfPackageRegistered(result, resultText);
}
catch (Exception e)
{
resultText = e.Message;
}
if (pkgRegistered == true)
{
notification.showInstallationHasCompleted();
}
else
{
notification.showError(resultText);
}
_deferral.Complete();
}
/// <summary>
/// Upgrades the appx/appxbundle from the path if needed.
/// </summary>
public static void InstallPackage(string appxFilePath, params string[] dependencyAppxFilePaths)
{
// Ensure the files exist.
if (!File.Exists(appxFilePath))
{
throw new FileNotFoundException(appxFilePath);
}
foreach (var path in dependencyAppxFilePaths.Where(p => !File.Exists(p)))
{
throw new FileNotFoundException(path);
}
Log.Comment($"Starting install of app package at {appxFilePath}");
PackageManager packageManager = new PackageManager();
var deploymentOperation = packageManager.AddPackageAsync(
new Uri(appxFilePath),
dependencyAppxFilePaths.Select(d => new Uri(d)),
DeploymentOptions.ForceApplicationShutdown | DeploymentOptions.ForceTargetApplicationShutdown | DeploymentOptions.ForceUpdateFromAnyVersion);
WaitForDeploymentOperation(deploymentOperation);
Log.Comment("Completed install of app package");
}
/// <summary>
/// Installs the unit test app
/// </summary>
public static void InstallTestAppIfNeeded(string deploymentDir, string packageName, string packageFamilyName)
{
if (!TestAppxInstalled.Contains(packageFamilyName))
{
FileInfo appxFile = new FileInfo(Path.Combine(deploymentDir, packageName + ".appx"));
if (appxFile.Exists)
{
PackageManager packageManager = new PackageManager();
DeploymentResult result = null;
var installedPackages = packageManager.FindPackagesForUser(string.Empty, packageFamilyName);
foreach (var installedPackage in installedPackages)
{
Log.Comment("Test AppX package already installed. Removing existing package by name: {0}", installedPackage.Id.FullName);
AutoResetEvent removePackageCompleteEvent = new AutoResetEvent(false);
var removePackageOperation = packageManager.RemovePackageAsync(installedPackage.Id.FullName);
removePackageOperation.Completed = (operation, status) =>
{
if (status != AsyncStatus.Started)
{
result = operation.GetResults();
removePackageCompleteEvent.Set();
}
};
removePackageCompleteEvent.WaitOne();
if (!string.IsNullOrEmpty(result.ErrorText))
{
Log.Error("Removal failed!");
Log.Error("Package removal ActivityId = {0}", result.ActivityId);
Log.Error("Package removal ErrorText = {0}", result.ErrorText);
Log.Error("Package removal ExtendedErrorCode = {0}", result.ExtendedErrorCode);
}
else
{
Log.Comment("Removal successful.");
}
}
// The test app has not been installed yet. Install it so tests can pass
List <Uri> depsPackages = new List <Uri>();
FileInfo dependenciesTextFile = new FileInfo(Path.Combine(deploymentDir, packageName + ".dependencies.txt"));
if (dependenciesTextFile.Exists)
{
Log.Comment("Including dependencies from {0}", dependenciesTextFile.FullName);
foreach (string line in File.ReadAllLines(dependenciesTextFile.FullName))
{
var dependencyPackageUri = new Uri(Path.Combine(deploymentDir, line));
Log.Comment("Adding dependency package: {0}", dependencyPackageUri.AbsolutePath);
depsPackages.Add(dependencyPackageUri);
}
}
var packageUri = new Uri(Path.Combine(deploymentDir, appxFile.FullName));
Log.Comment("Installing Test Appx Package: {0}", packageUri.AbsolutePath);
AutoResetEvent addPackageCompleteEvent = new AutoResetEvent(false);
var addPackageOperation = packageManager.AddPackageAsync(packageUri, depsPackages, DeploymentOptions.ForceApplicationShutdown);
addPackageOperation.Completed = (operation, status) =>
{
if (status != AsyncStatus.Started)
{
result = operation.GetResults();
addPackageCompleteEvent.Set();
}
};
addPackageCompleteEvent.WaitOne();
if (!string.IsNullOrEmpty(result.ErrorText))
{
Log.Error("Installation failed!");
Log.Error("Package installation ActivityId = {0}", result.ActivityId);
Log.Error("Package installation ErrorText = {0}", result.ErrorText);
Log.Error("Package installation ExtendedErrorCode = {0}", result.ExtendedErrorCode);
throw new Exception("Failed to install Test Appx Package: " + result.ErrorText);
}
else
{
Log.Comment("Installation successful.");
}
}
else
{
Log.Comment("Test Appx Package was not found in {0}.", deploymentDir);
}
TestAppxInstalled.Add(packageFamilyName);
}
}
/// <summary>
/// Pretty much identical to showProgressInApp() in MainPage.xaml.cs
/// </summary>
/// <param name="taskInstance"></param>
public async void Run(IBackgroundTaskInstance taskInstance)
{
boom = taskInstance;
_deferral = taskInstance.GetDeferral();
ApplicationTriggerDetails details = (ApplicationTriggerDetails)taskInstance.TriggerDetails;
string packagePath = "";
packagePath = (string)details.Arguments["packagePath"];
PackageManager pkgManager = new PackageManager();
Progress <DeploymentProgress> progressCallback = new Progress <DeploymentProgress>(installProgress);
notification.SendUpdatableToastWithProgress(0);
if ((int)details.Arguments["installType"] == 1)
{
List <Uri> dependencies = new List <Uri>();
var dependencyPairs = details.Arguments.Where(p => p.Key.Contains("d")).ToList();
foreach (var dependencyPair in dependencyPairs)
{
string dependencyAsString = (string)dependencyPair.Value;
dependencies.Add(new Uri(dependencyAsString));
}
try
{
var result = await pkgManager.AddPackageAsync(new Uri(packagePath), dependencies, DeploymentOptions.ForceTargetApplicationShutdown).AsTask(progressCallback);
checkIfPackageRegistered(result, resultText);
}
catch (Exception e)
{
resultText = e.Message;
}
}
else
{
try
{
var result = await pkgManager.AddPackageAsync(new Uri(packagePath), null, DeploymentOptions.ForceTargetApplicationShutdown).AsTask(progressCallback);
checkIfPackageRegistered(result, resultText);
}
catch (Exception e)
{
resultText = e.Message;
}
}
if (pkgRegistered == true)
{
notification.showInstallationHasCompleted();
}
else
{
notification.showError(resultText);
}
_deferral.Complete();
}
public static async Task <bool> InstallPackage(Package package, ProductDetails product)
{
try
{
// Download the file to the app's temp directory
//var client = new System.Net.WebClient();
string filepath = Path.Combine(ApplicationData.Current.TemporaryFolder.Path, package.Name);
//client.DownloadFile(package.Uri, filepath);
StorageFile destinationFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(
package.Name, CreationCollisionOption.ReplaceExisting);
BackgroundDownloader downloader = new BackgroundDownloader();
//downloader.SuccessToastNotification = GenerateDownloadSuccessToast(package, product);
downloader.FailureToastNotification = GenerateDownloadFailureToast(package, product);
var progressToast = GenerateProgressToast(package, product);
DownloadOperation download = downloader.CreateDownload(package.Uri, destinationFile);
download.RangesDownloaded += (op, args) =>
{
ToastNotificationManager.GetDefault().CreateToastNotifier().Update(
new NotificationData(new Dictionary <string, string>()
{
{ "progressValue", ((double)op.Progress.BytesReceived / op.Progress.TotalBytesToReceive).ToString() },
{ "progressStatus", "Downloading..." }
}),
progressToast.Tag
);
};
ToastNotificationManager.GetDefault().CreateToastNotifier().Show(progressToast);
await download.StartAsync();
PackageManager pkgManager = new PackageManager();
Progress <DeploymentProgress> progressCallback = new Progress <DeploymentProgress>(prog =>
{
ToastNotificationManager.GetDefault().CreateToastNotifier().Update(
new NotificationData(new Dictionary <string, string>()
{
{ "progressValue", (prog.percentage / 100).ToString() },
{ "progressStatus", "Installing..." }
}),
progressToast.Tag
);
});
// Attempt to install the downloaded package
var result = await pkgManager.AddPackageAsync(new Uri(filepath), new Uri[] { }, DeploymentOptions.ForceTargetApplicationShutdown).AsTask(progressCallback);
if (result.IsRegistered)
{
// Remove the progress notifcation
ToastNotificationManager.GetDefault().CreateToastNotifier().Hide(progressToast);
// Show the success notification
ToastNotificationManager.GetDefault().CreateToastNotifier().Show(GenerateInstallSuccessToast(package, product));
return(true);
}
else
{
return(false);
}
// Pass the file to App Installer to install it
//Uri launchUri = new Uri("ms-appinstaller:?source=" + filepath);
//switch (await Launcher.QueryUriSupportAsync(launchUri, LaunchQuerySupportType.Uri))
//{
// case LaunchQuerySupportStatus.Available:
// return await Launcher.LaunchUriAsync(launchUri);
// default:
// return false;
//}
}
catch
{
return(false);
}
}
