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);
}
}
}