private static async Task <MsixPackageVisuals> GetVisualsFromManifest(string installLocation, CancellationToken cancellationToken = default)
{
try
{
cancellationToken.ThrowIfCancellationRequested();
var reader = await AppxManifestSummaryBuilder.FromInstallLocation(installLocation).ConfigureAwait(false);
var logo = Path.Combine(installLocation, reader.Logo);
if (File.Exists(Path.Combine(installLocation, logo)))
{
return(new MsixPackageVisuals(
reader.DisplayName,
reader.DisplayPublisher,
logo,
reader.Description,
reader.AccentColor,
reader.PackageType));
}
var extension = Path.GetExtension(logo);
var baseName = Path.GetFileNameWithoutExtension(logo);
var baseFolder = Path.GetDirectoryName(logo);
logo = null;
// ReSharper disable once AssignNullToNotNullAttribute
var dirInfo = new DirectoryInfo(Path.Combine(installLocation, baseFolder));
if (dirInfo.Exists)
{
var found = dirInfo.EnumerateFiles(baseName + "*" + extension).FirstOrDefault();
if (found != null)
{
logo = found.FullName;
}
}
cancellationToken.ThrowIfCancellationRequested();
return(new MsixPackageVisuals(reader.DisplayName, reader.DisplayPublisher, logo, reader.Description, reader.AccentColor, reader.PackageType));
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception)
{
return(new MsixPackageVisuals());
}
}
public AppInstallerConfig Build(PackageType packageType = PackageType.Package)
{
var appIns = new AppInstallerConfig();
appIns.UpdateSettings = new UpdateSettings();
switch (this.CheckForUpdates)
{
case AppInstallerUpdateCheckingMethod.Never:
appIns.UpdateSettings.OnLaunch = null;
appIns.UpdateSettings.AutomaticBackgroundTask = null;
break;
case AppInstallerUpdateCheckingMethod.Launch:
appIns.UpdateSettings.OnLaunch = new OnLaunchSettings();
appIns.UpdateSettings.AutomaticBackgroundTask = null;
break;
case AppInstallerUpdateCheckingMethod.LaunchAndBackground:
appIns.UpdateSettings.OnLaunch = new OnLaunchSettings();
appIns.UpdateSettings.AutomaticBackgroundTask = new AutomaticBackgroundTaskSettings();
break;
case AppInstallerUpdateCheckingMethod.Background:
appIns.UpdateSettings.OnLaunch = null;
appIns.UpdateSettings.AutomaticBackgroundTask = new AutomaticBackgroundTaskSettings();
break;
default:
throw new ArgumentOutOfRangeException();
}
if (this.AllowDowngrades)
{
appIns.UpdateSettings.ForceUpdateFromAnyVersion = true;
}
appIns.UpdateSettings.ForceUpdateFromAnyVersion = this.AllowDowngrades;
if (appIns.UpdateSettings.OnLaunch != null)
{
appIns.UpdateSettings.OnLaunch.UpdateBlocksActivation = this.UpdateBlocksActivation;
appIns.UpdateSettings.OnLaunch.ShowPrompt = this.ShowPrompt;
if (this.HoursBetweenUpdateChecks != 24)
{
appIns.UpdateSettings.OnLaunch.HoursBetweenUpdateChecks = this.HoursBetweenUpdateChecks;
}
}
if (this.MainPackageSource != null)
{
AppxManifestSummary manifest;
if (string.Equals("appxmanifest.xml", Path.GetFileName(this.MainPackageSource.FullName), StringComparison.OrdinalIgnoreCase))
{
manifest = AppxManifestSummaryBuilder.FromManifest(this.MainPackageSource.FullName, AppxManifestSummaryBuilderMode.Identity).GetAwaiter().GetResult();
}
else
{
manifest = AppxManifestSummaryBuilder.FromMsix(this.MainPackageSource.FullName, AppxManifestSummaryBuilderMode.Identity).GetAwaiter().GetResult();
}
if (packageType == PackageType.Bundle)
{
appIns.MainBundle = new AppInstallerBundleEntry
{
Name = manifest.Name,
Version = manifest.Version,
Publisher = manifest.Publisher,
Uri = this.MainPackageUri?.ToString()
};
}
else
{
appIns.MainPackage = new AppInstallerPackageEntry
{
Name = manifest.Name,
Version = manifest.Version,
Publisher = manifest.Publisher,
Uri = this.MainPackageUri?.ToString()
};
if (manifest.ProcessorArchitecture == null)
{
appIns.MainPackage.Architecture = AppInstallerPackageArchitecture.neutral;
}
else if (Enum.TryParse(manifest.ProcessorArchitecture, true, out AppInstallerPackageArchitecture parsed))
{
appIns.MainPackage.Architecture = parsed;
}
}
}
else
{
if (packageType == PackageType.Bundle)
{
appIns.MainBundle = new AppInstallerBundleEntry
{
Name = this.MainPackageName,
Version = this.MainPackageVersion,
Publisher = MainPackagePublisher,
Uri = this.MainPackageUri?.ToString()
};
}
else if (packageType == PackageType.Package)
{
appIns.MainPackage = new AppInstallerPackageEntry
{
Name = this.MainPackageName,
Version = this.MainPackageVersion,
Publisher = MainPackagePublisher,
Uri = this.MainPackageUri?.ToString(),
Architecture = (AppInstallerPackageArchitecture)Enum.Parse(typeof(AppInstallerPackageArchitecture), this.MainPackageArchitecture.ToString("G"), true)
};
}
}
if (!appIns.UpdateSettings.ForceUpdateFromAnyVersion && appIns.UpdateSettings.OnLaunch == null && appIns.UpdateSettings.AutomaticBackgroundTask == null)
{
appIns.UpdateSettings = null;
}
if (this.RedirectUri != null)
{
appIns.Uri = this.RedirectUri.ToString();
}
appIns.Version = this.Version ?? "1.0.0.0";
return(appIns);
}
public async Task Add(string filePath, AddAppxPackageOptions options = 0, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
if (SideloadingChecker.GetStatus() < SideloadingStatus.Sideloading)
{
throw new DeveloperModeException("Developer mode or sideloading must be enabled to install packages outside of Microsoft Store.");
}
Logger.Info("Installing package {0}", filePath);
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (string.Equals(Path.GetFileName(filePath), "AppxManifest.xml", StringComparison.OrdinalIgnoreCase))
{
var reader = await AppxManifestSummaryBuilder.FromManifest(filePath).ConfigureAwait(false);
DeploymentOptions deploymentOptions = 0;
if (options.HasFlag(AddAppxPackageOptions.AllowDowngrade))
{
deploymentOptions |= DeploymentOptions.ForceUpdateFromAnyVersion;
}
if (options.HasFlag(AddAppxPackageOptions.KillRunningApps))
{
deploymentOptions |= DeploymentOptions.ForceApplicationShutdown;
deploymentOptions |= DeploymentOptions.ForceTargetApplicationShutdown;
}
deploymentOptions |= DeploymentOptions.DevelopmentMode;
await AsyncOperationHelper.ConvertToTask(
PackageManager.Value.RegisterPackageAsync(new Uri(filePath), Enumerable.Empty <Uri>(), deploymentOptions),
$"Installing {reader.DisplayName} {reader.Version}...",
cancellationToken,
progress).ConfigureAwait(false);
}
else if (string.Equals(".appinstaller", Path.GetExtension(filePath), StringComparison.OrdinalIgnoreCase))
{
if (options.HasFlag(AddAppxPackageOptions.AllUsers))
{
throw new NotSupportedException("Cannot install a package from .appinstaller for all users.");
}
AddPackageByAppInstallerOptions deploymentOptions = 0;
if (options.HasFlag(AddAppxPackageOptions.AllowDowngrade))
{
throw new NotSupportedException("Cannot force a downgrade with .appinstaller. The .appinstaller defines on its own whether the downgrade is allowed.");
}
if (options.HasFlag(AddAppxPackageOptions.KillRunningApps))
{
deploymentOptions |= AddPackageByAppInstallerOptions.ForceTargetAppShutdown;
}
var volume = PackageManager.Value.GetDefaultPackageVolume();
await AsyncOperationHelper.ConvertToTask(
PackageManager.Value.AddPackageByAppInstallerFileAsync(new Uri(filePath, UriKind.Absolute), deploymentOptions, volume),
"Installing from " + Path.GetFileName(filePath) + "...",
cancellationToken,
progress).ConfigureAwait(false);
}
else
{
try
{
var reader = await AppxManifestSummaryBuilder.FromMsix(filePath).ConfigureAwait(false);
DeploymentOptions deploymentOptions = 0;
if (options.HasFlag(AddAppxPackageOptions.AllowDowngrade))
{
deploymentOptions |= DeploymentOptions.ForceUpdateFromAnyVersion;
}
if (options.HasFlag(AddAppxPackageOptions.KillRunningApps))
{
deploymentOptions |= DeploymentOptions.ForceApplicationShutdown;
deploymentOptions |= DeploymentOptions.ForceTargetApplicationShutdown;
}
if (options.HasFlag(AddAppxPackageOptions.AllUsers))
{
var deploymentResult = await AsyncOperationHelper.ConvertToTask(
PackageManager.Value.AddPackageAsync(new Uri(filePath, UriKind.Absolute), Enumerable.Empty <Uri>(), deploymentOptions),
$"Installing {reader.DisplayName} {reader.Version}...",
cancellationToken,
progress).ConfigureAwait(false);
if (!deploymentResult.IsRegistered)
{
throw new InvalidOperationException("The package could not be registered.");
}
var findInstalled = PackageManager.Value.FindPackages(reader.Name, reader.Publisher).FirstOrDefault();
if (findInstalled == null)
{
throw new InvalidOperationException("The package could not be registered.");
}
var familyName = findInstalled.Id.FamilyName;
await AsyncOperationHelper.ConvertToTask(
PackageManager.Value.ProvisionPackageForAllUsersAsync(familyName),
$"Provisioning {reader.DisplayName} {reader.Version}...",
cancellationToken,
progress).ConfigureAwait(false);
}
else
{
var deploymentResult = await AsyncOperationHelper.ConvertToTask(
PackageManager.Value.AddPackageAsync(new Uri(filePath, UriKind.Absolute), Enumerable.Empty <Uri>(), deploymentOptions),
"Installing " + reader.DisplayName + "...",
cancellationToken,
progress).ConfigureAwait(false);
if (!deploymentResult.IsRegistered)
{
throw new InvalidOperationException("The package could not be registered.");
}
}
}
catch (InvalidDataException e)
{
throw new InvalidOperationException("File " + filePath + " does not seem to be a valid MSIX package." + e, e);
}
}
}
private async void OnAddPackage(string packagePath, bool forAllUsers)
{
if (packagePath == null)
{
if (forAllUsers)
{
if (!this.interactionService.SelectFile(FileDialogSettings.FromFilterString(new DialogFilterBuilder("*.msix", "*.appx").BuildFilter()), out packagePath))
{
return;
}
}
else
{
if (!this.interactionService.SelectFile(
// ReSharper disable StringLiteralTypo
FileDialogSettings.FromFilterString(new DialogFilterBuilder("*.msix", "*.appx", "*.appxbundle", "*.appinstaller", "appxmanifest.xml").BuildFilter()), out packagePath))
// ReSharper restore StringLiteralTypo
{
return;
}
}
}
AddAppxPackageOptions options = 0;
if (forAllUsers)
{
options |= AddAppxPackageOptions.AllUsers;
}
options |= AddAppxPackageOptions.KillRunningApps;
var context = this.busyManager.Begin();
try
{
using (var wrappedProgress = new WrappedProgress(context))
{
var p1 = wrappedProgress.GetChildProgress(90);
var p2 = wrappedProgress.GetChildProgress(10);
var manager = await this.packageManagerProvider.GetProxyFor(forAllUsers?SelfElevationLevel.AsAdministrator : SelfElevationLevel.AsInvoker).ConfigureAwait(false);
await manager.Add(packagePath, options, progress : p1).ConfigureAwait(false);
AppxManifestSummary appxReader;
if (!string.Equals(".appinstaller", Path.GetExtension(packagePath), StringComparison.OrdinalIgnoreCase))
{
appxReader = await AppxManifestSummaryBuilder.FromFile(packagePath, AppxManifestSummaryBuilderMode.Properties | AppxManifestSummaryBuilderMode.Identity).ConfigureAwait(false);
#pragma warning disable 4014
this.interactionService.ShowToast("App installed", $"{appxReader.DisplayName ?? appxReader.Name} has been just installed.", InteractionType.None);
#pragma warning restore 4014
}
else
{
appxReader = null;
#pragma warning disable 4014
this.interactionService.ShowToast("App installed", $"A new app has been just installed from {Path.GetFileName(packagePath)}.", InteractionType.None);
#pragma warning restore 4014
}
var allPackages = await this.application.CommandExecutor.Invoke <GetPackagesCommand, IList <InstalledPackage> >(this, new GetPackagesCommand(forAllUsers ? PackageFindMode.AllUsers : PackageFindMode.CurrentUser), progress : p2).ConfigureAwait(false);
if (appxReader != null)
{
var selected = allPackages.FirstOrDefault(p => p.Name == appxReader.Name);
if (selected != null)
{
//this.application.ApplicationState.Packages.SelectedPackages.Clear();
//this.application.ApplicationState.Packages.SelectedPackages.Add(selected);
await this.application.CommandExecutor.Invoke(this, new SelectPackagesCommand(selected.ManifestLocation)).ConfigureAwait(false);
}
}
else
{
await this.application.CommandExecutor.Invoke(this, new SelectPackagesCommand()).ConfigureAwait(false);
}
}
}
catch (Exception exception)
{
this.interactionService.ShowError("The package could not be added.", exception);
}
finally
{
this.busyManager.End(context);
}
}
