public override Task <Diagonosis> Examine(PatientHistory history)
{
var files = new List <string>();
var contributingCheckupIds = new[] { "dotnet", "visualstudio" };
foreach (var checkupId in contributingCheckupIds)
{
if (history.TryGetNotes <string[]>(checkupId, "sentinel_files", out var dotnetSentinelFiles) && (dotnetSentinelFiles?.Any() ?? false))
{
files.AddRange(dotnetSentinelFiles);
}
}
var missingFiles = new List <string>();
foreach (var file in files.Distinct())
{
// Check if exists
if (!File.Exists(file))
{
missingFiles.Add(file);
}
}
if (missingFiles.Any())
{
return(Task.FromResult(
new Diagonosis(Status.Error, this, new Prescription("Create EnableWorkloadResolver.sentinel files.",
missingFiles.Select(f => new CreateFileRemedy(f)).ToArray()))));
}
return(Task.FromResult(Diagonosis.Ok(this)));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var vsinfo = await GetMacInfo();
var ok = false;
foreach (var vs in vsinfo)
{
if (vs.Version.IsCompatible(MinimumVersion, ExactVersion))
{
ok = true;
ReportStatus($"Visual Studio for Mac ({vs.Version})", Status.Ok);
}
else
{
ReportStatus($"Visual Studio for Mac ({vs.Version})", null);
}
}
if (ok)
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(Status.Error, this));
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
var jdks = FindJdks();
var ok = false;
foreach (var jdk in jdks)
{
if ((jdk.JavaC.FullName.Contains("microsoft") || jdk.JavaC.FullName.Contains("openjdk")) &&
jdk.Version.IsCompatible(MinimumVersion, ExactVersion))
{
ok = true;
ReportStatus($"{jdk.Version} ({jdk.Directory})", Status.Ok);
Util.SetDoctorEnvironmentVariable("JAVA_HOME", jdk.Directory.FullName);
}
else
{
ReportStatus($"{jdk.Version} ({jdk.Directory})", null);
}
}
if (ok)
{
return(Task.FromResult(Diagonosis.Ok(this)));
}
return(Task.FromResult(new Diagonosis(Status.Error, this)));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var vsinfo = await GetWindowsInfo();
var sentinelFiles = new List <string>();
foreach (var vi in vsinfo)
{
if (vi.Version.IsCompatible(MinimumVersion, ExactVersion))
{
ReportStatus($"{vi.Version} - {vi.Path}", Status.Ok);
var sentinel = Path.Combine(vi.Path, "MSBuild\\Current\\Bin\\SdkResolvers\\Microsoft.DotNet.MSBuildSdkResolver\\EnableWorkloadResolver.sentinel");
sentinelFiles.Add(sentinel);
}
else
{
ReportStatus($"{vi.Version}", null);
}
}
if (sentinelFiles.Any())
{
history.AddNotes(this, "sentinel_files", sentinelFiles.ToArray());
}
if (vsinfo.Any(vs => vs.Version.IsCompatible(MinimumVersion, ExactVersion)))
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(Status.Error, this));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var installedWorkloads = workloadManager.GetInstalledWorkloads();
var missingWorkloads = new List <Manifest.DotNetWorkload>();
var requiredPacks = new List <WorkloadResolver.PackInfo>();
foreach (var rp in RequiredWorkloads)
{
if (!installedWorkloads.Any(sp => sp == rp.Id))
{
ReportStatus($"{rp.Id} not installed.", Status.Error);
missingWorkloads.Add(rp);
}
else
{
ReportStatus($"{rp.Id} installed.", Status.Ok);
var workloadPacks = workloadManager.GetPacksInWorkload(rp.Id);
if (workloadPacks != null && workloadPacks.Any())
{
foreach (var wp in workloadPacks)
{
if (!(rp.IgnoredPackIds?.Any(ip => ip.Equals(wp.Id, StringComparison.OrdinalIgnoreCase)) ?? false))
{
requiredPacks.Add(wp);
}
}
}
}
}
if (requiredPacks.Any())
{
history.AddNotes(this, "required_packs", requiredPacks.ToArray());
}
if (!missingWorkloads.Any())
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(
Status.Error,
this,
new Prescription("Install Missing SDK Workloads",
new DotNetWorkloadInstallRemedy(SdkRoot, SdkVersion, missingWorkloads.ToArray(), NuGetPackageSources))));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var info = await GetInfo();
if (NuGetVersion.TryParse(info.Version?.ToString(), out var semVer))
{
if (semVer.IsCompatible(MinimumVersion, ExactVersion))
{
ReportStatus($"XCode.app ({info.Version} {info.Build})", Status.Ok);
return(Diagonosis.Ok(this));
}
}
ReportStatus($"XCode.app ({info.Version}) not installed.", Status.Error);
return(new Diagonosis(Status.Error, this, new Prescription($"Download XCode {MinimumVersion.ThisOrExact(ExactVersion)}")));
}
public override async Task <Diagonosis> Examine(PatientHistory history)
{
var sdkPacks = workloadManager.GetAllInstalledWorkloadPacks();
var missingPacks = new List <NuGetPackage>();
var requiredPacks = new List <NuGetPackage>();
requiredPacks.AddRange(RequiredPacks);
if (history.TryGetNotes <WorkloadResolver.PackInfo[]>("dotnetworkloads", "required_packs", out var p) && p.Any())
{
requiredPacks.AddRange(p.Select(pi => new NuGetPackage {
Id = pi.Id, Version = pi.Version
}));
}
var uniqueRequiredPacks = requiredPacks
.GroupBy(p => p.Id + p.Version.ToString())
.Select(g => g.First());
foreach (var rp in uniqueRequiredPacks)
{
if (!sdkPacks.Any(sp => sp.Id == rp.Id && sp.Version == rp.Version))
{
ReportStatus($"{rp.Id} ({rp.Version}) not installed.", Status.Warning);
missingPacks.Add(rp);
}
else
{
ReportStatus($"{rp.Id} ({rp.Version}) installed.", Status.Ok);
}
}
if (!missingPacks.Any())
{
return(Diagonosis.Ok(this));
}
return(new Diagonosis(
Status.Error,
this,
new Prescription("Install Missing SDK Packs",
new DotNetPackInstallRemedy(SdkRoot, SdkVersion, missingPacks.ToArray(), NuGetPackageSources))));;
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
var android = new AndroidSdk.AndroidSdkManager(
Util.GetDoctorEnvironmentVariable("ANDROID_SDK_ROOT") ?? Util.GetDoctorEnvironmentVariable("ANDROID_HOME"));
var packages = android.SdkManager.List().InstalledPackages;
var missingPackages = new List <Manifest.AndroidPackage>();
foreach (var rp in RequiredPackages)
{
if (!packages.Any(p => p.Path.Equals(rp.Path, StringComparison.OrdinalIgnoreCase) &&
NuGetVersion.Parse(p.Version) >= NuGetVersion.Parse(rp.Version)))
{
ReportStatus($"{rp.Path} ({rp.Version}) missing.", Status.Error);
missingPackages.Add(rp);
}
else
{
ReportStatus($"{rp.Path} ({rp.Version})", Status.Ok);
}
}
if (!missingPackages.Any())
{
return(Task.FromResult(Diagonosis.Ok(this)));
}
var remedies = Util.IsMac ? new AndroidPackagesRemedy[] { new AndroidPackagesRemedy(android, missingPackages.ToArray()) } : null;
return(Task.FromResult(new Diagonosis(
Status.Error,
this,
new Prescription("Install missing Android SDK items",
"Your Android SDK is missing some required packages. You can use the Android SDK Manager to install them. For more information see: https://aka.ms/dotnet-androidsdk-help",
remedies))));
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
var android = new AndroidSdk.AndroidSdkManager(
Util.GetDoctorEnvironmentVariable("ANDROID_SDK_ROOT") ?? Util.GetDoctorEnvironmentVariable("ANDROID_HOME"));
try
{
var v = android.SdkManager.RequiresLicenseAcceptance();
if (!v)
{
ReportStatus($"All licenses accepted.", Status.Ok);
return(Task.FromResult(Diagonosis.Ok(this)));
}
}
catch { }
ReportStatus("One or more Licenses are not accepted.", Status.Error);
var ext = Util.IsWindows ? ".bat" : string.Empty;
var sdkMgrPath = android.SdkManager.FindToolPath(android.Home)?.FullName;
if (string.IsNullOrEmpty(sdkMgrPath))
{
sdkMgrPath = $"sdkmanager{ext}";
}
return(Task.FromResult(new Diagonosis(Status.Error, this, new Prescription("Android SDK has licenses which need to be accepted.",
$"To read and accept Android SDK licenses, run the following command in a terminal:{Environment.NewLine} {sdkMgrPath} --licenses"))));
//,new ActionRemedy((r, ct) =>
//{
// android.SdkManager.AcceptLicenses();
// return Task.CompletedTask;
//}))));
}
public override Task <Diagonosis> Examine(PatientHistory history)
{
try
{
var homes = AndroidSdk.AndroidSdkManager.FindHome();
foreach (var home in homes)
{
try
{
var sdk = new AndroidSdk.SdkManager(home);
var v = sdk.GetVersion();
if (v != default)
{
if (SelectedHome == default)
{
SelectedHome = home;
SdkManagerPath = sdk.FindToolPath(SelectedHome);
if (SdkManagerPath != null)
{
Util.SetDoctorEnvironmentVariable("ANDROID_SDK_ROOT", SdkManagerPath.FullName);
Util.SetDoctorEnvironmentVariable("ANDROID_HOME", SdkManagerPath.FullName);
}
ReportStatus($"{home.FullName} ({v}) installed.", Status.Ok);
}
else
{
ReportStatus($"{home.FullName} ({v}) also installed.", Status.Ok);
}
}
else
{
ReportStatus($"{home.FullName} invalid.", Status.Warning);
}
}
catch
{
ReportStatus($"{home.FullName} invalid.", Status.Warning);
}
}
if (SelectedHome != default)
{
return(Task.FromResult(Diagonosis.Ok(this)));
}
} catch { }
return(Task.FromResult(
new Diagonosis(
Status.Error,
this,
"Failed to find Android SDK.",
new Prescription("Please Install the Android SDK Manager. For more information see: https://aka.ms/dotnet-androidsdk-help")))); //,
//new ActionRemedy((r, ct) =>
//{
// if (SelectedHome != null)
// {
// if (SelectedHome.Exists)
// {
// try { SelectedHome.Delete(true); }
// catch (UnauthorizedAccessException)
// {
// throw new Exception("Fix requires running with adminstrator privileges. Try opening a terminal as administrator and running maui-doctor again.");
// }
// catch (Exception ex)
// {
// throw new Exception("Failed to delete existing Android SDK: " + ex.Message);
// }
// try { SelectedHome.Create(); }
// catch { }
// }
// }
// else
// {
// SelectedHome = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Android", "android-sdk"));
// try { SelectedHome.Create(); }
// catch { }
// }
// var sdk = new AndroidSdk.AndroidSdkManager(SelectedHome);
// sdk.Acquire();
// return Task.CompletedTask;
//}))));
}
