/// <summary>
/// Gets the filename to the specific package <paramref name="packageName"/> using the version <paramref name="versionRange"/> if not null, otherwise the <paramref name="constraintProvider"/> if specified.
/// If no constraints are specified, the first entry if any are founds is used to get the filename.
/// </summary>
/// <param name="packageName">Name of the package.</param>
/// <param name="versionRange">The version range.</param>
/// <param name="constraintProvider">The package constraint provider.</param>
/// <param name="allowPreleaseVersion">if set to <c>true</c> [allow prelease version].</param>
/// <param name="allowUnlisted">if set to <c>true</c> [allow unlisted].</param>
/// <returns>A location on the disk to the specified package or null if not found.</returns>
/// <exception cref="System.ArgumentNullException">packageName</exception>
public UFile GetPackageFileName(string packageName, PackageVersionRange versionRange = null, ConstraintProvider constraintProvider = null, bool allowPreleaseVersion = true, bool allowUnlisted = false)
{
if (packageName == null)
{
throw new ArgumentNullException(nameof(packageName));
}
var package = store.FindLocalPackage(packageName, versionRange, constraintProvider, allowPreleaseVersion, allowUnlisted);
// If package was not found,
if (package != null)
{
var packageRoot = (UDirectory)store.GetRealPath(package);
var packageFilename = new UFile(packageName + Package.PackageFileExtension);
// First look for xkpkg at package root
var packageFile = UPath.Combine(packageRoot, packageFilename);
if (File.Exists(packageFile))
{
return(packageFile);
}
// Then look for xkpkg inside xenko subfolder
packageFile = UPath.Combine(UPath.Combine(packageRoot, (UDirectory)"xenko"), packageFilename);
if (File.Exists(packageFile))
{
return(packageFile);
}
}
return(null);
}
/// <summary>
/// Gets the filename to the specific package <paramref name="packageName"/> using the version <paramref name="versionRange"/> if not null, otherwise the <paramref name="constraintProvider"/> if specified.
/// If no constraints are specified, the first entry if any are founds is used to get the filename.
/// </summary>
/// <param name="packageName">Name of the package.</param>
/// <param name="versionRange">The version range.</param>
/// <param name="constraintProvider">The package constraint provider.</param>
/// <param name="allowPreleaseVersion">if set to <c>true</c> [allow prelease version].</param>
/// <param name="allowUnlisted">if set to <c>true</c> [allow unlisted].</param>
/// <returns>A location on the disk to the specified package or null if not found.</returns>
/// <exception cref="System.ArgumentNullException">packageName</exception>
public UFile GetPackageFileName(string packageName, PackageVersionRange versionRange = null, ConstraintProvider constraintProvider = null, bool allowPreleaseVersion = true, bool allowUnlisted = false)
{
if (packageName == null)
{
throw new ArgumentNullException(nameof(packageName));
}
var package = store.FindLocalPackage(packageName, versionRange, constraintProvider, allowPreleaseVersion, allowUnlisted);
// If package was not found,
if (package != null)
{
return(UPath.Combine(store.GetRealPath(package), new UFile(packageName + Package.PackageFileExtension)));
}
// TODO: Check version for default package
if (packageName == DefaultPackageName)
{
if (versionRange == null || versionRange.Contains(DefaultPackageVersion))
{
//return UPath.Combine(UPath.Combine(UPath.Combine(InstallationPath, (UDirectory)store.RepositoryPath), defaultPackageDirectory), new UFile(packageName + Package.PackageFileExtension));
}
}
return(null);
}
/// <summary>
/// Gets the xenko SDK dir.
/// </summary>
/// <returns></returns>
internal static async Task <PackageInfo> FindXenkoSdkDir(string solution, string packageName = "Xenko.VisualStudio.Commands")
{
// Resolve the sdk version to load from the solution's package
var packageInfo = new PackageInfo {
ExpectedVersion = await PackageSessionHelper.GetPackageVersion(solution), SdkPaths = new List <string>()
};
// Check if we are in a root directory with store/packages facilities
var store = new NugetStore(null);
NugetLocalPackage xenkoPackage = null;
// Try to find the package with the expected version
if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion)
{
// Xenko up to 3.0
if (packageInfo.ExpectedVersion < new PackageVersion(3, 1, 0, 0))
{
xenkoPackage = store.GetPackagesInstalled(new[] { "Xenko" }).FirstOrDefault(package => package.Version == packageInfo.ExpectedVersion);
if (xenkoPackage != null)
{
var xenkoSdkDir = store.GetRealPath(xenkoPackage);
packageInfo.LoadedVersion = xenkoPackage.Version;
foreach (var path in new[]
{
// Xenko 2.x and 3.0
@"Bin\Windows\Direct3D11",
@"Bin\Windows",
// Xenko 1.x
@"Bin\Windows-Direct3D11"
})
{
var fullPath = Path.Combine(xenkoSdkDir, path);
if (Directory.Exists(fullPath))
{
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.dll", SearchOption.TopDirectoryOnly));
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.exe", SearchOption.TopDirectoryOnly));
}
}
}
}
// Xenko 3.1+
else
{
var logger = new Logger();
var(request, result) = await RestoreHelper.Restore(logger, packageName, new VersionRange(packageInfo.ExpectedVersion.ToNuGetVersion()));
if (result.Success)
{
packageInfo.SdkPaths.AddRange(RestoreHelper.ListAssemblies(request, result));
packageInfo.LoadedVersion = packageInfo.ExpectedVersion;
}
}
}
return(packageInfo);
}
/// <summary>
/// Gets the xenko SDK dir.
/// </summary>
/// <returns></returns>
private static PackageInfo FindXenkoSdkDir()
{
// Resolve the sdk version to load from the solution's package
var packageInfo = new PackageInfo {
ExpectedVersion = PackageSessionHelper.GetPackageVersion(solution)
};
// TODO: Maybe move it in some common class somewhere? (in this case it would be included with "Add as link" in VSPackage)
var xenkoSdkDir = Environment.GetEnvironmentVariable("XenkoDir");
// Failed to locate xenko
if (xenkoSdkDir == null)
{
return(packageInfo);
}
// If we are in a dev directory, assume we have the right version
if (File.Exists(Path.Combine(xenkoSdkDir, "build\\Xenko.sln")))
{
packageInfo.StorePath = xenkoSdkDir;
packageInfo.SdkPath = xenkoSdkDir;
packageInfo.LoadedVersion = packageInfo.ExpectedVersion;
return(packageInfo);
}
// Check if we are in a root directory with store/packages facilities
var store = new NugetStore(xenkoSdkDir);
NugetLocalPackage xenkoPackage = null;
// Try to find the package with the expected version
if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion)
{
xenkoPackage = store.GetPackagesInstalled(store.MainPackageIds).FirstOrDefault(package => GetVersion(package) == packageInfo.ExpectedVersion);
}
// If the expected version is not found, get the latest package
if (xenkoPackage == null)
{
xenkoPackage = store.GetLatestPackageInstalled(store.MainPackageIds);
}
// If no package was found, return no sdk path
if (xenkoPackage == null)
{
return(packageInfo);
}
// Return the loaded version and the sdk path
packageInfo.LoadedVersion = GetVersion(xenkoPackage);
packageInfo.StorePath = xenkoSdkDir;
packageInfo.SdkPath = store.GetRealPath(xenkoPackage);
return(packageInfo);
}
/// <summary>
/// Gets the stride SDK dir.
/// </summary>
/// <returns></returns>
internal static async Task <PackageInfo> FindStrideSdkDir(string solution, string packageName = "Stride.VisualStudio.Commands")
{
// Resolve the sdk version to load from the solution's package
var packageInfo = new PackageInfo {
ExpectedVersion = await PackageSessionHelper.GetPackageVersion(solution), SdkPaths = new List <string>()
};
// Check if we are in a root directory with store/packages facilities
var store = new NugetStore(null);
NugetLocalPackage stridePackage = null;
// Try to find the package with the expected version
if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion)
{
// Stride up to 3.0
if (packageInfo.ExpectedVersion < new PackageVersion(3, 1, 0, 0))
{
stridePackage = store.GetPackagesInstalled(new[] { "Stride" }).FirstOrDefault(package => package.Version == packageInfo.ExpectedVersion);
if (stridePackage != null)
{
var strideSdkDir = store.GetRealPath(stridePackage);
packageInfo.LoadedVersion = stridePackage.Version;
foreach (var path in new[]
{
// Stride 2.x and 3.0
@"Bin\Windows\Direct3D11",
@"Bin\Windows",
// Stride 1.x
@"Bin\Windows-Direct3D11"
})
{
var fullPath = Path.Combine(strideSdkDir, path);
if (Directory.Exists(fullPath))
{
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.dll", SearchOption.TopDirectoryOnly));
packageInfo.SdkPaths.AddRange(Directory.EnumerateFiles(fullPath, "*.exe", SearchOption.TopDirectoryOnly));
}
}
}
}
// Stride 3.1+
else
{
var logger = new Logger();
var(request, result) = await RestoreHelper.Restore(logger, NuGetFramework.ParseFrameworkName(".NETFramework,Version=v4.7.2", DefaultFrameworkNameProvider.Instance), "win", packageName, new VersionRange(packageInfo.ExpectedVersion.ToNuGetVersion()));
if (result.Success)
{
packageInfo.SdkPaths.AddRange(RestoreHelper.ListAssemblies(request, result));
packageInfo.LoadedVersion = packageInfo.ExpectedVersion;
}
else
{
MessageBox.Show($"Could not restore {packageName} {packageInfo.ExpectedVersion}, this visual studio extension may fail to work properly without it."
+ $"To fix this you can either build {packageName} or pull the right version from nugget manually");
throw new InvalidOperationException($"Could not restore {packageName} {packageInfo.ExpectedVersion}.");
}
}
}
return(packageInfo);
}
public async Task RetrieveLocalXenkoVersions()
{
List <RecentProjectViewModel> currentRecentProjects;
lock (RecentProjects)
{
currentRecentProjects = new List <RecentProjectViewModel>(RecentProjects);
}
try
{
var localPackages = await RunLockTask(() => store.GetPackagesInstalled(store.MainPackageIds).FilterXenkoMainPackages().OrderByDescending(p => p.Version).ToList());
lock (objectLock)
{
// Retrieve all local packages
var packages = localPackages.Where(p => !store.IsDevRedirectPackage(p)).GroupBy(p => $"{p.Version.Version.Major}.{p.Version.Version.Minor}", p => p);
var updatedLocalPackages = new HashSet <XenkoStoreVersionViewModel>();
foreach (var package in packages)
{
var localPackage = package.FirstOrDefault();
if (localPackage != null)
{
// Find if we already have this package in our list
int index = xenkoVersions.BinarySearch(Tuple.Create(localPackage.Version.Version.Major, localPackage.Version.Version.Minor));
XenkoStoreVersionViewModel version;
if (index < 0)
{
// If not, add it
version = new XenkoStoreVersionViewModel(this, store, localPackage, localPackage.Version.Version.Major, localPackage.Version.Version.Minor);
Dispatcher.Invoke(() => xenkoVersions.Add(version));
}
else
{
version = (XenkoStoreVersionViewModel)xenkoVersions[index];
}
version.UpdateLocalPackage(localPackage);
updatedLocalPackages.Add(version);
}
}
// Update versions that are not installed locally anymore
Dispatcher.Invoke(() =>
{
foreach (var xenkoUninstalledVersion in xenkoVersions.OfType <XenkoStoreVersionViewModel>().Where(x => !updatedLocalPackages.Contains(x)))
{
xenkoUninstalledVersion.UpdateLocalPackage(null);
}
});
// Update the active version if it is now invalid.
if (ActiveVersion == null || !xenkoVersions.Contains(ActiveVersion) || !ActiveVersion.CanDelete)
{
ActiveVersion = XenkoVersions.FirstOrDefault(x => x.CanDelete);
}
if (!lastActiveVersionRestored)
{
var restoredVersion = XenkoVersions.FirstOrDefault(x => x.CanDelete && x.Name == LauncherSettings.ActiveVersion);
if (restoredVersion != null)
{
ActiveVersion = restoredVersion;
lastActiveVersionRestored = true;
}
}
}
var devPackages = localPackages.Where(store.IsDevRedirectPackage);
Dispatcher.Invoke(() => xenkoVersions.RemoveWhere(x => x is XenkoDevVersionViewModel));
foreach (var package in devPackages)
{
try
{
var realPath = store.GetRealPath(package);
var version = new XenkoDevVersionViewModel(this, store, package, realPath, true);
Dispatcher.Invoke(() => xenkoVersions.Add(version));
}
catch (Exception e)
{
await ServiceProvider.Get <IDialogService>().MessageBox(string.Format(Strings.ErrorDevRedirect, e), MessageBoxButton.OK, MessageBoxImage.Information);
}
}
}
catch (Exception e)
{
// TODO: error
e.Ignore();
}
finally
{
Dispatcher.Invoke(() =>
{
foreach (var project in currentRecentProjects)
{
// Manually discarding the possibility to upgrade from 1.0
if (project.XenkoVersionName == "1.0")
{
continue;
}
project.CompatibleVersions.Clear();
foreach (var version in XenkoVersions)
{
// We suppose all dev versions are compatible with any project.
if (version is XenkoDevVersionViewModel)
{
project.CompatibleVersions.Add(version);
}
var storeVersion = version as XenkoStoreVersionViewModel;
if (storeVersion != null && storeVersion.CanDelete)
{
// Discard the version that matches the recent project version
if (project.XenkoVersion == new Version(storeVersion.Version.Version.Major, storeVersion.Version.Version.Minor))
{
continue;
}
// Discard the versions that are anterior to the recent project version
if (project.XenkoVersion > storeVersion.Version.Version)
{
continue;
}
project.CompatibleVersions.Add(version);
}
}
}
});
}
}
