bool InstallBCL(Context context)
{
string redistListDir = MonoRuntimesHelpers.BCLRedistListDestinationDir;
foreach (KeyValuePair <BclFileTarget, string> kvp in MonoRuntimesHelpers.BCLDestinationDirs)
{
Utilities.CreateDirectory(kvp.Value);
}
foreach (KeyValuePair <BclFileTarget, string> kvp in MonoRuntimesHelpers.BCLFacadesDestinationDirs)
{
Utilities.CreateDirectory(kvp.Value);
}
Utilities.CreateDirectory(redistListDir);
StatusStep(context, "Installing Android BCL assemblies");
InstallBCLFiles(allRuntimes.BclFilesToInstall);
StatusStep(context, "Installing Designer Host BCL assemblies");
InstallBCLFiles(allRuntimes.DesignerHostBclFilesToInstall);
StatusStep(context, "Installing Designer Windows BCL assemblies");
InstallBCLFiles(allRuntimes.DesignerWindowsBclFilesToInstall);
return(GenerateFrameworkList(
context,
MonoRuntimesHelpers.FrameworkListPath,
MonoRuntimesHelpers.BCLDestinationDirs [BclFileTarget.Android],
MonoRuntimesHelpers.BCLFacadesDestinationDirs [BclFileTarget.Android]
));
}
bool InstallUtilities(Context context)
{
string destDir = MonoRuntimesHelpers.UtilitiesDestinationDir;
Utilities.CreateDirectory(destDir);
string managedRuntime = context.Properties.GetRequiredValue(KnownProperties.ManagedRuntime);
bool haveManagedRuntime = !String.IsNullOrEmpty(managedRuntime);
string remapper = Utilities.GetRelativePath(BuildPaths.XamarinAndroidSourceRoot, context.Properties.GetRequiredValue(KnownProperties.RemapAssemblyRefToolExecutable));
string targetCecil = Utilities.GetRelativePath(BuildPaths.XamarinAndroidSourceRoot, Path.Combine(Configurables.Paths.BuildBinDir, "Xamarin.Android.Cecil.dll"));
StatusStep(context, "Installing runtime utilities");
foreach (MonoUtilityFile muf in allRuntimes.UtilityFilesToInstall)
{
(string destFilePath, string debugSymbolsDestPath) = MonoRuntimesHelpers.GetDestinationPaths(muf);
Utilities.CopyFile(muf.SourcePath, destFilePath);
if (!muf.IgnoreDebugInfo)
{
if (!String.IsNullOrEmpty(debugSymbolsDestPath))
{
Utilities.CopyFile(muf.DebugSymbolsPath, debugSymbolsDestPath);
}
else
{
Log.DebugLine($"Debug symbols not found for utility file {Path.GetFileName (muf.SourcePath)}");
}
}
if (!muf.RemapCecil)
{
continue;
}
string relDestFilePath = Utilities.GetRelativePath(BuildPaths.XamarinAndroidSourceRoot, destFilePath);
StatusSubStep(context, $"Remapping Cecil references for {relDestFilePath}");
bool result = Utilities.RunCommand(
haveManagedRuntime ? managedRuntime : remapper, // command
BuildPaths.XamarinAndroidSourceRoot, // workingDirectory
true, // ignoreEmptyArguments
// arguments
haveManagedRuntime ? remapper : String.Empty,
Utilities.GetRelativePath(BuildPaths.XamarinAndroidSourceRoot, muf.SourcePath),
relDestFilePath,
"Mono.Cecil",
targetCecil);
if (result)
{
continue;
}
Log.ErrorLine($"Failed to remap cecil reference for {destFilePath}");
return(false);
}
return(true);
}
async Task <bool> FetchFiles(HashSet <string> neededFiles, string destinationDirectory, Uri url)
{
Utilities.CreateDirectory(destinationDirectory);
using (var httpClient = new HttpClient()) {
bool success;
long size;
Log.StatusLine($"Accessing {url}");
(success, size) = await GetFileSize(httpClient, url);
if (!success)
{
return(false);
}
Log.DebugLine($" File size: {size}");
EOCD eocd;
(success, eocd) = await GetEOCD(httpClient, url, size);
if (!success)
{
Log.ErrorLine("Failed to find the End of Central Directory record");
return(false);
}
if (eocd.DiskNumber != 0)
{
throw new InvalidOperationException("Multi-disk ZIP archives not supported");
}
Log.DebugLine($" Central Directory offset: {eocd.CDOffset} (0x{eocd.CDOffset:x})");
Log.DebugLine($" Central Directory size: {eocd.CDSize} (0x{eocd.CDSize})");
Log.DebugLine($" Total Entries: {eocd.TotalEntries}");
Stream cd;
(success, cd) = await ReadCD(httpClient, url, eocd.CDOffset, eocd.CDSize, size);
if (!success)
{
Log.ErrorLine("Failed to read the Central Directory");
return(false);
}
Log.StatusLine("Files:");
if (!await ProcessEntries(httpClient, url, eocd, cd, neededFiles, destinationDirectory))
{
return(false);
}
}
return(true);
}
protected override async Task <bool> Execute(Context context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
Uri nugetUrl = Configurables.Urls.NugetUri;
string localNugetPath = Configurables.Paths.LocalNugetPath;
if (Utilities.FileExists(localNugetPath))
{
Log.StatusLine($"NuGet already downloaded ({localNugetPath})");
return(true);
}
Utilities.CreateDirectory(Path.GetDirectoryName(localNugetPath));
Log.StatusLine("Downloading NuGet");
(bool success, ulong size, HttpStatusCode status) = await Utilities.GetDownloadSizeWithStatus(nugetUrl);
if (!success)
{
if (status == HttpStatusCode.NotFound)
{
Log.ErrorLine("NuGet URL not found");
}
else
{
Log.ErrorLine("Failed to obtain NuGet size. HTTP status code: {status} ({(int)status})");
}
return(false);
}
DownloadStatus downloadStatus = Utilities.SetupDownloadStatus(context, size, context.InteractiveSession);
Log.StatusLine($" {context.Characters.Link} {nugetUrl}", ConsoleColor.White);
await Download(context, nugetUrl, localNugetPath, "NuGet", Path.GetFileName(localNugetPath), downloadStatus);
if (!File.Exists(localNugetPath))
{
Log.ErrorLine($"Download of NuGet from {nugetUrl} failed");
return(false);
}
return(true);
}
protected override async Task <bool> Execute(Context context)
{
string hostDestinationDirectory = Configurables.Paths.HostBinutilsInstallDir;
string windowsDestinationDirectory = Configurables.Paths.WindowsBinutilsInstallDir;
bool hostHaveAll = HaveAllBinutils(hostDestinationDirectory);
bool windowsHaveAll = HaveAllBinutils(windowsDestinationDirectory, ".exe");
if (hostHaveAll && windowsHaveAll)
{
Log.StatusLine("All Binutils are already installed");
return(true);
}
string packageName = Path.GetFileName(Configurables.Urls.BinutilsArchive.LocalPath);
string localArchivePath = Path.Combine(Configurables.Paths.BinutilsCacheDir, packageName);
if (!await DownloadBinutils(context, localArchivePath, Configurables.Urls.BinutilsArchive))
{
return(false);
}
string tempDir = Path.Combine(Path.GetTempPath(), "xaprepare-binutils");
Utilities.DeleteDirectorySilent(tempDir);
Utilities.CreateDirectory(tempDir);
Log.DebugLine($"Unpacking {ProductName} archive {localArchivePath} into {tempDir}");
if (!await Utilities.Unpack(localArchivePath, tempDir, cleanDestinatioBeforeUnpacking: true))
{
return(false);
}
if (!hostHaveAll)
{
CopyToDestination(context, "Host", tempDir, hostDestinationDirectory, executableExtension: ExecutableExtension);
}
if (!windowsHaveAll)
{
CopyToDestination(context, "Windows", tempDir, windowsDestinationDirectory, "windows", ".exe");
}
return(true);
}
async Task <bool> Unpack(string fullArchivePath, string destinationDirectory, bool cleanDestinationBeforeUnpacking = false)
{
// https://bintray.com/jetbrains/intellij-jdk/download_file?file_path=jbrsdk-8u202-windows-x64-b1483.37.tar.gz
// doesn't contain a single root directory! This causes the
// "JetBrains root directory not found after unpacking" check to fail on Windows.
// "Fix" things by setting destinationDirectory to contain RootDirName, allowing
// the check to succeed.
if (JdkVersion == Configurables.Defaults.JetBrainsOpenJDK8Version)
{
destinationDirectory = Path.Combine(destinationDirectory, RootDirName);
}
// On Windows we don't have Tar available and the Windows package is a .tar.gz
// 7zip can unpack tar.gz but it's a two-stage process - first it decompresses the package, then it can be
// invoked again to extract the actual tar contents.
if (cleanDestinationBeforeUnpacking)
{
Utilities.DeleteDirectorySilent(destinationDirectory);
}
Utilities.CreateDirectory(destinationDirectory);
var sevenZip = new SevenZipRunner(Context.Instance);
Log.DebugLine($"Uncompressing {fullArchivePath} to {destinationDirectory}");
if (!await sevenZip.Extract(fullArchivePath, destinationDirectory))
{
Log.DebugLine($"Failed to decompress {fullArchivePath}");
return(false);
}
string tarPath = Path.Combine(destinationDirectory, Path.GetFileNameWithoutExtension(fullArchivePath));
bool ret = await sevenZip.Extract(tarPath, destinationDirectory);
Utilities.DeleteFileSilent(tarPath);
if (!ret)
{
Log.DebugLine($"Failed to extract TAR contents from {tarPath}");
return(false);
}
return(true);
}
public async Task <bool> Clone(string url, string destinationDirectoryPath)
{
if (String.IsNullOrEmpty(url))
{
throw new ArgumentException("must not be null or empty", nameof(url));
}
if (String.IsNullOrEmpty(destinationDirectoryPath))
{
throw new ArgumentException("must not be null or empty", nameof(destinationDirectoryPath));
}
string parentDir = Path.GetDirectoryName(destinationDirectoryPath);
string dirName = Path.GetFileName(destinationDirectoryPath);
Utilities.CreateDirectory(parentDir);
var runner = CreateGitRunner(parentDir);;
runner.AddArgument("clone");
runner.AddArgument("--progress");
runner.AddQuotedArgument(url);
return(await RunGit(runner, $"clone-{dirName}"));
}
async Task <bool> Unpack(string fullArchivePath, string destinationDirectory, bool cleanDestinationBeforeUnpacking = false)
{
if (cleanDestinationBeforeUnpacking)
{
Utilities.DeleteDirectorySilent(destinationDirectory);
}
Utilities.CreateDirectory(destinationDirectory);
var sevenZip = new SevenZipRunner(Context.Instance);
Log.DebugLine($"Uncompressing {fullArchivePath} to {destinationDirectory}");
if (!await sevenZip.Extract(fullArchivePath, destinationDirectory))
{
Log.DebugLine($"Failed to decompress {fullArchivePath}");
return(false);
}
if (fullArchivePath.EndsWith("tar.gz", StringComparison.OrdinalIgnoreCase))
{
// On Windows we don't have Tar available and the Windows package is a .tar.gz
// 7zip can unpack tar.gz but it's a two-stage process - first it decompresses the package, then it can be
// invoked again to extract the actual tar contents.
string tarPath = Path.Combine(destinationDirectory, Path.GetFileNameWithoutExtension(fullArchivePath));
bool ret = await sevenZip.Extract(tarPath, destinationDirectory);
Utilities.DeleteFileSilent(tarPath);
if (!ret)
{
Log.DebugLine($"Failed to extract TAR contents from {tarPath}");
return(false);
}
}
return(true);
}
protected void EnsureOutputDir()
{
Utilities.CreateDirectory(Path.GetDirectoryName(OutputPath));
}
async Task <bool> ConjureXamarinCecilAndRemapRef(Context context, bool haveManagedRuntime, string managedRuntime)
{
StatusStep(context, "Building remap-assembly-ref");
bool result = await Utilities.BuildRemapRef(context, haveManagedRuntime, managedRuntime, quiet : true);
if (!result)
{
return(false);
}
var msbuild = new MSBuildRunner(context);
StatusStep(context, "Building conjure-xamarin-android-cecil");
string projectPath = Path.Combine(Configurables.Paths.BuildToolsDir, "conjure-xamarin-android-cecil", "conjure-xamarin-android-cecil.csproj");
result = await msbuild.Run(
projectPath : projectPath,
logTag : "conjure-xamarin-android-cecil",
binlogName : "build-conjure-xamarin-android-cecil"
);
if (!result)
{
Log.ErrorLine("Failed to build conjure-xamarin-android-cecil");
return(false);
}
StatusStep(context, "Conjuring Xamarin.Android.Cecil and Xamari.Android.Cecil.Mdb");
string conjurer = Path.Combine(Configurables.Paths.BuildBinDir, "conjure-xamarin-android-cecil.exe");
string conjurerSourceDir = Configurables.Paths.MonoProfileToolsDir;
string conjurerDestDir = Configurables.Paths.BuildBinDir;
result = Utilities.RunCommand(
haveManagedRuntime ? managedRuntime : conjurer, // command
BuildPaths.XamarinAndroidSourceRoot, // workingDirectory
true, // ignoreEmptyArguments
// arguments
haveManagedRuntime ? conjurer : String.Empty,
Configurables.Paths.MonoProfileToolsDir, // source dir
Configurables.Paths.BuildBinDir // destination dir
);
StatusStep(context, "Re-signing Xamarin.Android.Cecil.dll");
var sn = new SnRunner(context);
string snkPath = Path.Combine(BuildPaths.XamarinAndroidSourceRoot, "mono.snk");
string assemblyPath = Path.Combine(Configurables.Paths.BuildBinDir, "Xamarin.Android.Cecil.dll");
result = await sn.ReSign(snkPath, assemblyPath, $"sign-xamarin-android-cecil");
if (!result)
{
Log.ErrorLine("Failed to re-sign Xamarin.Android.Cecil.dll");
return(false);
}
Utilities.CreateDirectory(Configurables.Paths.NetCoreBinDir);
Utilities.CopyFile(assemblyPath, Path.Combine(Configurables.Paths.NetCoreBinDir, "Xamarin.Android.Cecil.dll"));
StatusStep(context, "Re-signing Xamarin.Android.Cecil.Mdb.dll");
assemblyPath = Path.Combine(Configurables.Paths.BuildBinDir, "Xamarin.Android.Cecil.Mdb.dll");
result = await sn.ReSign(snkPath, assemblyPath, $"sign-xamarin-android-cecil-mdb");
if (!result)
{
Log.ErrorLine("Failed to re-sign Xamarin.Android.Cecil.Mdb.dll");
return(false);
}
Utilities.CopyFile(assemblyPath, Path.Combine(Configurables.Paths.NetCoreBinDir, "Xamarin.Android.Cecil.Mdb.dll"));
return(true);
}
async Task <(bool disabled, bool success)> ConfigureBuildAndInstall(Context context, string abiName)
{
if (!context.IsHostJitAbiEnabled(abiName))
{
Log.DebugLine($"Windows target {abiName} disabled, not building libzip");
return(true, true);
}
bool sixtyFourBit = context.Is64BitMingwHostAbi(abiName);
string sourceDir = context.Properties.GetRequiredValue(KnownProperties.LibZipSourceFullPath);
string buildDir = Path.Combine(Configurables.Paths.BuildBinDir, $"libzip-windows-{abiName}");
string stampFile = Path.Combine(buildDir, $".build-{context.BuildInfo.FullLibZipHash}");
string outputPath;
if (sixtyFourBit)
{
outputPath = Path.Combine("x64", LibZipName);
}
else
{
outputPath = LibZipName;
}
string sourceFile = Path.Combine(buildDir, "lib", LibZipName);
string destFile = Path.Combine(Configurables.Paths.LibZipOutputPath, outputPath);
bool needBuild;
if (Utilities.FileExists(stampFile) && Utilities.FileExists(sourceFile))
{
Log.DebugLine($"LibZip-Windows build stamp file exists: {stampFile}");
Log.StatusLine($"LibZip for {abiName} already built, skipping compilation");
needBuild = false;
}
else
{
needBuild = true;
}
if (needBuild)
{
Utilities.DeleteDirectorySilent(buildDir);
Utilities.CreateDirectory(buildDir);
List <string> arguments = GetCmakeArguments(context, buildDir, sixtyFourBit);
string logTag = $"libzip-windows-{abiName}";
var cmake = new CMakeRunner(context);
bool result = await cmake.Run(
logTag : logTag,
sourceDirectory : sourceDir,
workingDirectory : buildDir,
arguments : arguments
);
if (!result)
{
return(false, false);
}
var ninja = new NinjaRunner(context);
result = await ninja.Run(
logTag : logTag,
workingDirectory : buildDir
);
if (!result)
{
return(false, false);
}
}
Utilities.CopyFile(sourceFile, destFile);
if (!File.Exists(destFile))
{
Log.ErrorLine($"Failed to copy {sourceFile} to {destFile}");
return(false, false);
}
TouchStampFile(stampFile);
return(false, true);
}