public async Task <AppxPackage> GetByManifestPath(string manifestPath, PackageFindMode mode = PackageFindMode.CurrentUser, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
using IAppxFileReader reader = new FileInfoFileReaderAdapter(manifestPath);
var manifestReader = new AppxManifestReader();
// ReSharper disable once AccessToDisposedClosure
var package = await Task.Run(() => manifestReader.Read(reader, true, cancellationToken), cancellationToken).ConfigureAwait(false);
return(package);
}
public Task <List <InstalledPackage> > GetInstalledPackages(PackageFindMode mode = PackageFindMode.Auto, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
var proxyObject = new GetInstalledPackagesDto
{
Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers
};
return(this.client.Get(proxyObject, cancellationToken, progress));
}
public async Task <AppxPackage> GetByIdentity(string packageName, PackageFindMode mode = PackageFindMode.CurrentUser, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
using var reader = new PackageIdentityFileReaderAdapter(mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers, packageName);
var manifestReader = new AppxManifestReader();
// ReSharper disable once AccessToDisposedClosure
var package = await Task.Run(() => manifestReader.Read(reader, true, cancellationToken), cancellationToken).ConfigureAwait(false);
return(package);
}
public Task <AppxPackage> GetByManifestPath(string manifestPath, PackageFindMode mode = PackageFindMode.CurrentUser, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
var proxyObject = new GetByManifestPathDto
{
Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers,
Source = manifestPath
};
return(this.client.Get(proxyObject, cancellationToken, progress));
}
public async Task <bool> IsInstalled(string manifestPath, PackageFindMode mode = PackageFindMode.CurrentUser, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
PackageFindMode actualMode = mode;
if (actualMode == PackageFindMode.Auto)
{
var isAdmin = await UserHelper.IsAdministratorAsync(cancellationToken).ConfigureAwait(false);
if (isAdmin)
{
actualMode = PackageFindMode.AllUsers;
}
else
{
actualMode = PackageFindMode.CurrentUser;
}
}
string pkgFullName;
using (var src = FileReaderFactory.CreateFileReader(manifestPath))
{
var manifestReader = new AppxManifestReader();
var parsed = await manifestReader.Read(src, false, cancellationToken).ConfigureAwait(false);
pkgFullName = parsed.FullName;
}
switch (actualMode)
{
case PackageFindMode.CurrentUser:
var pkg = await Task.Run(
() => PackageManagerWrapper.Instance.FindPackageForUser(string.Empty, pkgFullName),
cancellationToken).ConfigureAwait(false);
return(pkg != null);
case PackageFindMode.AllUsers:
var pkgAllUsers = await Task.Run(
() => PackageManagerWrapper.Instance.FindPackage(pkgFullName),
cancellationToken).ConfigureAwait(false);
return(pkgAllUsers != null);
default:
throw new NotSupportedException();
}
}
public async Task <bool> IsInstalled(string manifestPath, PackageFindMode mode = PackageFindMode.CurrentUser, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
if (mode == PackageFindMode.Auto)
{
if (await UserHelper.IsAdministratorAsync(cancellationToken).ConfigureAwait(false))
{
mode = PackageFindMode.AllUsers;
}
else
{
mode = PackageFindMode.CurrentUser;
}
}
var proxyObject = new CheckIfInstalledDto
{
ManifestFilePath = manifestPath,
Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers
};
return(await this.client.Get(proxyObject, cancellationToken, progress));
}
public async Task <List <InstalledPackage> > GetModificationPackages(string packageFullName, PackageFindMode mode = PackageFindMode.Auto, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
if (mode == PackageFindMode.Auto)
{
if (await UserHelper.IsAdministratorAsync(cancellationToken).ConfigureAwait(false))
{
mode = PackageFindMode.AllUsers;
}
else
{
mode = PackageFindMode.CurrentUser;
}
}
var proxyObject = new GetModificationPackagesDto
{
FullPackageName = packageFullName,
Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers
};
return(await this.client.Get(proxyObject, cancellationToken, progress));
}
private async Task <List <InstalledPackage> > GetInstalledPackages(string packageName, PackageFindMode mode, CancellationToken cancellationToken, IProgress <ProgressData> progress = default)
{
var list = new List <InstalledPackage>();
var provisioned = new HashSet <string>();
var isAdmin = await UserHelper.IsAdministratorAsync(cancellationToken).ConfigureAwait(false);
if (mode == PackageFindMode.Auto)
{
mode = isAdmin ? PackageFindMode.AllUsers : PackageFindMode.CurrentUser;
}
progress?.Report(new ProgressData(0, "Getting installed apps..."));
if (isAdmin)
{
Logger.Info("Getting provisioned packages...");
var tempFile = Path.GetTempFileName();
try
{
var cmd = "(Get-AppxProvisionedPackage -Online).PackageName | Out-File '" + tempFile + "'";
var proc = new ProcessStartInfo("powershell.exe", "-NoLogo -WindowStyle Hidden -Command \"&{ " + cmd + "}\"")
{
UseShellExecute = false,
CreateNoWindow = true
};
Logger.Debug("Executing powershell.exe " + "-Command \"&{ " + cmd + "}\"");
var p = Process.Start(proc);
if (p == null)
{
Logger.Error("Could not get the list of provisioned apps.");
}
else
{
p.WaitForExit();
foreach (var line in await File.ReadAllLinesAsync(tempFile, cancellationToken).ConfigureAwait(false))
{
provisioned.Add(line.Replace("~", string.Empty));
}
}
}
finally
{
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
}
}
progress?.Report(new ProgressData(5, "Getting installed apps..."));
IList <Package> allPackages;
if (string.IsNullOrEmpty(packageName))
{
Logger.Info("Getting all packages by find mode = '{0}'", mode);
switch (mode)
{
case PackageFindMode.CurrentUser:
allPackages = await Task.Run(() => PackageManager.Value.FindPackagesForUserWithPackageTypes(string.Empty, PackageTypes.Framework | PackageTypes.Main | PackageTypes.Optional).ToList(), cancellationToken).ConfigureAwait(false);
break;
case PackageFindMode.AllUsers:
allPackages = await Task.Run(() => PackageManager.Value.FindPackagesWithPackageTypes(PackageTypes.Framework | PackageTypes.Main | PackageTypes.Optional).ToList(), cancellationToken).ConfigureAwait(false);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
else
{
Logger.Info("Getting package name '{0}' by find mode = '{1}'", packageName, mode);
switch (mode)
{
case PackageFindMode.CurrentUser:
allPackages = new List <Package>
{
await Task.Run(() => PackageManager.Value.FindPackageForUser(string.Empty, packageName), cancellationToken).ConfigureAwait(false)
};
break;
case PackageFindMode.AllUsers:
allPackages = new List <Package>
{
await Task.Run(() => PackageManager.Value.FindPackage(packageName), cancellationToken).ConfigureAwait(false)
};
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
}
progress?.Report(new ProgressData(30, "Getting installed apps..."));
var total = 10.0;
var single = allPackages.Count == 0 ? 0.0 : 90.0 / allPackages.Count;
var cnt = 0;
var all = allPackages.Count;
var tasks = new HashSet <Task <InstalledPackage> >();
var config = await configurationService.GetCurrentConfigurationAsync(true, cancellationToken).ConfigureAwait(false);
int maxThreads;
if (config.Advanced?.DisableMultiThreadingForGetPackages == false || config.Advanced?.MaxThreadsForGetPackages < 2)
{
maxThreads = 1;
}
else if (config.Advanced?.MaxThreadsForGetPackages == null)
{
maxThreads = Environment.ProcessorCount;
}
else
{
maxThreads = Math.Min(config.Advanced?.MaxThreadsForGetPackages ?? 1, Environment.ProcessorCount);
}
var sw = new Stopwatch();
sw.Start();
foreach (var item in allPackages)
{
cnt += 1;
total += single;
progress?.Report(new ProgressData((int)total, $"Getting installed apps..."));
cancellationToken.ThrowIfCancellationRequested();
if (tasks.Count >= maxThreads)
{
var awaited = await Task.WhenAny(tasks).ConfigureAwait(false);
tasks.Remove(awaited);
var converted = await awaited.ConfigureAwait(false);
if (converted != null)
{
converted.Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers;
if (provisioned.Contains(converted.PackageId))
{
converted.IsProvisioned = true;
}
list.Add(converted);
}
}
tasks.Add(ConvertFrom(item, cancellationToken, progress));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
foreach (var item in tasks)
{
var converted = await item.ConfigureAwait(false);
if (converted != null)
{
converted.Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers;
if (provisioned.Contains(converted.PackageId))
{
converted.IsProvisioned = true;
}
list.Add(converted);
}
}
sw.Stop();
Logger.Info("Returning {0} packages (the operation took {1})...", list.Count, sw.Elapsed);
return(list);
}
public async Task <InstalledPackage> GetInstalledPackages(string packageName, string publisher, PackageFindMode mode = PackageFindMode.Auto, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
Package pkg;
switch (mode)
{
case PackageFindMode.CurrentUser:
pkg = await Task.Run(() => PackageManager.Value.FindPackagesForUser(packageName, publisher).First(), cancellationToken).ConfigureAwait(false);
break;
case PackageFindMode.AllUsers:
pkg = await Task.Run(() => PackageManager.Value.FindPackages(packageName, publisher).First(), cancellationToken).ConfigureAwait(false);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
}
if (pkg == null)
{
return(null);
}
var converted = await ConvertFrom(pkg, cancellationToken, progress).ConfigureAwait(false);
converted.Context = mode == PackageFindMode.CurrentUser ? PackageContext.CurrentUser : PackageContext.AllUsers;
return(converted);
}
public async Task <List <InstalledPackage> > GetModificationPackages(string packageFullName, PackageFindMode mode = PackageFindMode.Auto, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
if (mode == PackageFindMode.Auto)
{
mode = (await UserHelper.IsAdministratorAsync(cancellationToken).ConfigureAwait(false)) ? PackageFindMode.AllUsers : PackageFindMode.CurrentUser;
}
var find = await Task.Run(() => mode == PackageFindMode.CurrentUser?PackageManager.Value.FindPackageForUser(string.Empty, packageFullName) : PackageManager.Value.FindPackage(packageFullName), cancellationToken).ConfigureAwait(false);
if (find == null)
{
var packageIdentity = PackageIdentity.FromFullName(packageFullName);
find = await Task.Run(() => mode == PackageFindMode.CurrentUser?PackageManager.Value.FindPackageForUser(string.Empty, packageIdentity.AppName) : PackageManager.Value.FindPackage(packageIdentity.AppName), cancellationToken).ConfigureAwait(false);
if (find == null)
{
return(new List <InstalledPackage>());
}
}
var dependencies = find.Dependencies;
var list = new List <InstalledPackage>();
foreach (var dep in dependencies.Where(p => p.IsOptional))
{
var converted = await ConvertFrom(dep, cancellationToken).ConfigureAwait(false);
list.Add(converted);
}
return(list);
}
public Task <List <InstalledPackage> > GetInstalledPackages(PackageFindMode mode = PackageFindMode.Auto, CancellationToken cancellationToken = default, IProgress <ProgressData> progress = default)
{
return(GetInstalledPackages(null, mode, cancellationToken, progress));
}
public GetPackagesCommand(PackageFindMode findMode)
{
this.FindMode = findMode;
}
