public override bool Execute()
{
if (LaunchProfiles == null || UserFile == null || FlagFile == null || ProjectDirectory == null)
{
Log.LogWarning("MonitorActiveDocument : One or more files missing");
return(true);
}
if (!Directory.Exists(LaunchProfiles))
{
Log.LogWarning("LaunchProfiles not created yet");
return(true);
}
try
{
if (BuildEngine4.GetRegisteredTaskObject(nameof(ActiveDocumentMonitor), RegisteredTaskObjectLifetime.AppDomain) is not ActiveDocumentMonitor monitor)
{
if (WindowsInterop.GetServiceProvider() is IServiceProvider services)
{
BuildEngine4.RegisterTaskObject(nameof(ActiveDocumentMonitor),
new ActiveDocumentMonitor(LaunchProfiles, UserFile, FlagFile, ProjectDirectory, services),
RegisteredTaskObjectLifetime.AppDomain, false);
}
}
else
{
// NOTE: this means we only support ONE project/launchProfiles per IDE.
monitor.Refresh(LaunchProfiles, UserFile, FlagFile, ProjectDirectory);
}
}
string GetJvmPath()
{
// NOTE: this doesn't need to use GetRegisteredTaskObjectAssemblyLocal()
// because JavaSdkPath is the key and the value is a string.
var key = new Tuple <string, string> (nameof(ResolveJdkJvmPath), JavaSdkPath);
var cached = BuildEngine4.GetRegisteredTaskObject(key, RegisteredTaskObjectLifetime.AppDomain) as string;
if (cached != null)
{
Log.LogDebugMessage($"Using cached value for {nameof (JdkJvmPath)}: {cached}");
return(cached);
}
var minVersion = Version.Parse(MinimumSupportedJavaVersion);
var maxVersion = Version.Parse(LatestSupportedJavaVersion);
JdkInfo info = MonoAndroidHelper.GetJdkInfo(this.CreateTaskLogger(), JavaSdkPath, minVersion, maxVersion);
if (info == null)
{
return(null);
}
var path = info.JdkJvmPath;
if (string.IsNullOrEmpty(path))
{
return(null);
}
BuildEngine4.RegisterTaskObject(key, path, RegisteredTaskObjectLifetime.AppDomain, allowEarlyCollection: false);
return(path);
}
public override bool Execute()
{
try {
var path = Path.GetFullPath(LockFile);
var key = new Tuple <string, string> (nameof(WriteLockFile), path); // Use the full path as part of the key
// Check if already registered, for sanity
var existing = BuildEngine4.GetRegisteredTaskObject(key, RegisteredTaskObjectLifetime.Build) as DeleteFileAfterBuild;
if (existing == null)
{
if (File.Exists(path))
{
Log.LogCodedWarning("XA5302", "Two processes may be building this project at once. Lock file exists at path: {0}", path);
}
else
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
File.WriteAllText(path, "");
}
BuildEngine4.RegisterTaskObject(key, new DeleteFileAfterBuild(path), RegisteredTaskObjectLifetime.Build, allowEarlyCollection: false);
}
else
{
Log.LogDebugMessage("Lock file was created earlier in the build.");
}
} catch (Exception ex) {
Log.LogDebugMessage($"Exception in {nameof (WriteLockFile)}: {ex}");
}
// We want to always continue
return(true);
}
string GetJvmPath()
{
var key = new Tuple <string, string> (nameof(ResolveSdks), JavaSdkPath);
var cached = BuildEngine4.GetRegisteredTaskObject(key, RegisteredTaskObjectLifetime.AppDomain) as string;
if (cached != null)
{
Log.LogDebugMessage($"Using cached value for {nameof (JdkJvmPath)}: {cached}");
return(cached);
}
Xamarin.Android.Tools.JdkInfo info = null;
try {
info = new Xamarin.Android.Tools.JdkInfo(JavaSdkPath);
} catch {
info = Xamarin.Android.Tools.JdkInfo.GetKnownSystemJdkInfos(this.CreateTaskLogger()).FirstOrDefault();
}
if (info == null)
{
return(null);
}
var path = info.JdkJvmPath;
if (string.IsNullOrEmpty(path))
{
return(null);
}
BuildEngine4.RegisterTaskObject(key, path, RegisteredTaskObjectLifetime.AppDomain, allowEarlyCollection: false);
return(path);
}
public override bool Execute()
{
BuildEngine4.RegisterTaskObject(
CacheKey,
new RegisterObject(),
RegisteredTaskObjectLifetime.Build,
allowEarlyCollection: false);
return(true);
}
void WriteTypeMappings(List <TypeDefinition> types, TypeDefinitionCache cache)
{
var tmg = new TypeMapGenerator((string message) => Log.LogDebugMessage(message), SupportedAbis);
if (!tmg.Generate(Debug, SkipJniAddNativeMethodRegistrationAttributeScan, types, cache, TypemapOutputDirectory, GenerateNativeAssembly, out ApplicationConfigTaskState appConfState))
{
throw new XamarinAndroidException(4308, Properties.Resources.XA4308);
}
GeneratedBinaryTypeMaps = tmg.GeneratedBinaryTypeMaps.ToArray();
BuildEngine4.RegisterTaskObjectAssemblyLocal(ApplicationConfigTaskState.RegisterTaskObjectKey, appConfState, RegisteredTaskObjectLifetime.Build);
}
public override bool Execute()
{
if (string.IsNullOrEmpty(LaunchProfiles) ||
string.IsNullOrEmpty(UserFile))
{
Debug.Fail("Should have gotten something to monitor");
return(true);
}
try
{
if (BuildEngine4.GetRegisteredTaskObject(nameof(ActiveDocumentMonitor), RegisteredTaskObjectLifetime.AppDomain) is not ActiveDocumentMonitor monitor)
{
var maxAttempts = 5;
for (var i = 1; i <= maxAttempts; i++)
{
if (WindowsInterop.GetServiceProvider() is IServiceProvider services)
{
BuildEngine4.RegisterTaskObject(nameof(ActiveDocumentMonitor),
new ActiveDocumentMonitor(LaunchProfiles !, UserFile !,
StartupFiles.Select(x => x.ItemSpec).ToArray(), services),
RegisteredTaskObjectLifetime.AppDomain, false);
return(true);
}
else
{
try
{
BuildEngine4.Yield();
}
catch (Exception e)
{
Debug.WriteLine(e);
}
// Increase the wait time to allow more time between retries
Thread.Sleep(200 * i);
}
}
Debug.Fail("Failed to get IServiceProvider to monitor for active document.");
}
else
{
// NOTE: this means we only support ONE project/launchProfiles per IDE.
monitor.Refresh(LaunchProfiles !, UserFile !,
StartupFiles.Select(x => x.ItemSpec).ToArray());
}
}
bool GetAapt2Version()
{
var sb = new StringBuilder();
var aapt2Tool = Path.Combine(Aapt2ToolPath, Aapt2);
// Try to use a cached value for Aapt2Version
// NOTE: this doesn't need to use GetRegisteredTaskObjectAssemblyLocal()
// because the path to aapt2 is in the key and the value is a string.
var key = ($"{nameof (ResolveAndroidTooling)}.{nameof (Aapt2Version)}", aapt2Tool);
var cached = BuildEngine4.GetRegisteredTaskObject(key, RegisteredTaskObjectLifetime.AppDomain) as string;
if (!string.IsNullOrEmpty(cached))
{
Log.LogDebugMessage($"Using cached value for {nameof (Aapt2Version)}: {cached}");
Aapt2Version = cached;
return(true);
}
try {
MonoAndroidHelper.RunProcess(aapt2Tool, "version", (s, e) => {
if (!string.IsNullOrEmpty(e.Data))
{
sb.AppendLine(e.Data);
}
}, (s, e) => {
if (!string.IsNullOrEmpty(e.Data))
{
sb.AppendLine(e.Data);
}
}
);
} catch (Exception ex) {
Log.LogWarningFromException(ex);
return(false);
}
var versionInfo = sb.ToString();
var versionNumberMatch = Aapt2VersionRegex.Match(versionInfo);
Log.LogDebugMessage($"`{aapt2Tool} version` returned: ```{versionInfo}```");
if (versionNumberMatch.Success && Version.TryParse(versionNumberMatch.Groups ["version"]?.Value.Replace(":", "."), out Version versionNumber))
{
Aapt2Version = versionNumber.ToString();
BuildEngine4.RegisterTaskObject(key, Aapt2Version, RegisteredTaskObjectLifetime.AppDomain, allowEarlyCollection: false);
return(true);
}
return(false);
}
protected override void ExecuteCore()
{
const string previewMessageKey = "Microsoft.NET.Build.Tasks.DisplayPreviewMessageKey";
object messageDisplayed =
BuildEngine4.GetRegisteredTaskObject(previewMessageKey, RegisteredTaskObjectLifetime.Build);
if (messageDisplayed == null)
{
Log.LogMessage(MessageImportance.High, Strings.UsingPreviewSdkWarning);
BuildEngine4.RegisterTaskObject(
previewMessageKey,
new object(),
RegisteredTaskObjectLifetime.Build,
true);
}
}
public override bool Execute()
{
if (FlagFile == null || StartupFile == null)
{
return(true);
}
if (!File.Exists(FlagFile) || File.ReadAllText(FlagFile) != StartupFile)
{
// This defers the opening until the build completes.
BuildEngine4.RegisterTaskObject(
StartupFile,
new DisposableAction(() => WindowsInterop.EnsureOpened(StartupFile)),
RegisteredTaskObjectLifetime.Build, false);
File.WriteAllText(FlagFile, StartupFile);
}
return(true);
}
Version GetVersionFromTool(string javaExe, Regex versionRegex)
{
var javaTool = Path.Combine(JavaSdkPath, "bin", javaExe);
var key = new Tuple <string, string> (nameof(ValidateJavaVersion), javaTool);
var cached = BuildEngine4.GetRegisteredTaskObject(key, RegisteredTaskObjectLifetime.AppDomain) as Version;
if (cached != null)
{
Log.LogDebugMessage($"Using cached value for `{javaTool} -version`: {cached}");
JdkVersion = cached.ToString();
return(cached);
}
var sb = new StringBuilder();
MonoAndroidHelper.RunProcess(javaTool, "-version", (s, e) => {
if (!string.IsNullOrEmpty(e.Data))
{
sb.AppendLine(e.Data);
}
}, (s, e) => {
if (!string.IsNullOrEmpty(e.Data))
{
sb.AppendLine(e.Data);
}
});
var versionInfo = sb.ToString();
var versionNumberMatch = versionRegex.Match(versionInfo);
Version versionNumber;
if (versionNumberMatch.Success && Version.TryParse(versionNumberMatch.Groups ["version"]?.Value, out versionNumber))
{
BuildEngine4.RegisterTaskObject(key, versionNumber, RegisteredTaskObjectLifetime.AppDomain, allowEarlyCollection: false);
JdkVersion = versionNumberMatch.Groups ["version"].Value;
return(versionNumber);
}
else
{
Log.LogCodedWarning("XA0033", $"Failed to get the Java SDK version as it does not appear to contain a valid version number. `{javaExe} -version` returned: ```{versionInfo}```");
return(null);
}
}
private void ExecuteImpl()
{
var globalJsonPath = Path.Combine(RepositoryRoot, "global.json");
var lastWrite = File.GetLastWriteTimeUtc(globalJsonPath);
var paths = Environment.GetEnvironmentVariable("PATH");
var cachedResult = (CacheEntry)BuildEngine4.GetRegisteredTaskObject(s_cacheKey, RegisteredTaskObjectLifetime.Build);
if (cachedResult != null && lastWrite == cachedResult.LastWrite && paths == cachedResult.Paths)
{
Log.LogMessage(MessageImportance.Low, $"Reused cached value.");
DotNetPath = cachedResult.Value;
return;
}
var globalJson = File.ReadAllText(globalJsonPath);
// avoid Newtonsoft.Json dependency
var match = Regex.Match(globalJson, @"""dotnet""\s*:\s*""([^""]+)""");
if (!match.Success)
{
Log.LogError($"Unable to determine dotnet version from file '{globalJsonPath}'.");
return;
}
var sdkVersion = match.Groups[1].Value;
var fileName = (Path.DirectorySeparatorChar == '\\') ? "dotnet.exe" : "dotnet";
var dotNetDir = paths.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(p => File.Exists(Path.Combine(p, fileName)));
if (dotNetDir == null || !Directory.Exists(Path.Combine(dotNetDir, "sdk", sdkVersion)))
{
Log.LogError($"Unable to find dotnet with SDK version '{sdkVersion}'");
return;
}
DotNetPath = Path.GetFullPath(Path.Combine(dotNetDir, fileName));
BuildEngine4.RegisterTaskObject(s_cacheKey, new CacheEntry(lastWrite, paths, DotNetPath), RegisteredTaskObjectLifetime.Build, allowEarlyCollection: true);
}
public override bool Execute()
{
var logger = new Logger(Log);
var sandbox = BuildEngine4.GetRegisteredTaskObject(BuildEngine.ProjectFileOfTaskNode, RegisteredTaskObjectLifetime.Build) as Sanbox;
if (sandbox == null)
{
return(true);
}
try
{
sandbox.Client.ExecutePostBuildAdaptations(logger);
}
catch (Exception e)
{
logger.Error($"Assembly adaptation pre build execution failed. Details: {e.GetBaseException().Message}");
}
return(!Log.HasLoggedErrors);
}
string FindMono()
{
string mono = BuildEngine4.GetRegisteredTaskObjectAssemblyLocal <string> (MonoKey, Lifetime);
if (!string.IsNullOrEmpty(mono))
{
Log.LogDebugMessage($"Found cached mono via {nameof (BuildEngine4.RegisterTaskObject)}");
return(mono);
}
var env = Environment.GetEnvironmentVariable("PATH");
if (string.IsNullOrEmpty(env))
{
foreach (var path in env.Split(Path.PathSeparator))
{
if (File.Exists(mono = Path.Combine(path, "mono")))
{
Log.LogDebugMessage("Found mono in $PATH");
BuildEngine4.RegisterTaskObjectAssemblyLocal(MonoKey, mono, Lifetime);
return(mono);
}
}
}
foreach (var path in KnownMonoPaths)
{
if (File.Exists(mono = path))
{
Log.LogDebugMessage($"Found mono in {nameof (KnownMonoPaths)}");
BuildEngine4.RegisterTaskObjectAssemblyLocal(MonoKey, mono, Lifetime);
return(mono);
}
}
// Last resort
BuildEngine4.RegisterTaskObjectAssemblyLocal(MonoKey, mono = "mono", Lifetime);
return(mono);
}
string GetJvmPath()
{
// NOTE: this doesn't need to use GetRegisteredTaskObjectAssemblyLocal()
// because JavaSdkPath is the key and the value is a string.
var key = new Tuple <string, string> (nameof(ResolveJdkJvmPath), JavaSdkPath);
var cached = BuildEngine4.GetRegisteredTaskObject(key, RegisteredTaskObjectLifetime.AppDomain) as string;
if (cached != null)
{
Log.LogDebugMessage($"Using cached value for {nameof (JdkJvmPath)}: {cached}");
return(cached);
}
JdkInfo info = null;
try {
info = new JdkInfo(JavaSdkPath);
} catch {
info = JdkInfo.GetKnownSystemJdkInfos(this.CreateTaskLogger()).FirstOrDefault();
}
if (info == null)
{
return(null);
}
var path = info.JdkJvmPath;
if (string.IsNullOrEmpty(path))
{
return(null);
}
BuildEngine4.RegisterTaskObject(key, path, RegisteredTaskObjectLifetime.AppDomain, allowEarlyCollection: false);
return(path);
}
public override bool Execute()
{
var logger = new Logger(Log);
var sandbox = BuildEngine4.GetRegisteredTaskObject(BuildEngine.ProjectFileOfTaskNode, RegisteredTaskObjectLifetime.Build) as Sanbox;
if (sandbox == null)
{
return(true);
}
CompilesToAdd = Enumerable.Empty <ITaskItem>().ToArray();
CompilesToRemove = Enumerable.Empty <ITaskItem>().ToArray();
if (!Test && Assembly.GetEntryAssembly() == null)
{
return(true);
}
try
{
var replacements = sandbox.Client.ReplaceCompileItems(logger);
Func <CompileItemReplacement, ITaskItem> selector = r =>
{
return(ItemsCompile.FirstOrDefault(c => string.Equals(c.GetMetadata("FullPath"),
r.Source,
StringComparison.InvariantCultureIgnoreCase)));
};
CompilesToAdd = replacements.Select(r => new TaskItem(r.Target)).OfType <ITaskItem>().ToArray();
CompilesToRemove = replacements.Select(selector).ToArray();
}
catch (Exception e)
{
logger.Error($"Assembly compile replacement failed. Details: {e.GetBaseException().Message}");
}
return(!Log.HasLoggedErrors);
}
internal BuildResult InternalExecute()
{
BuildResult = new BuildResult()
{
SubmissionId = SubmissionId
};
try {
var engine = new BuildEngine4(this);
string toolsVersion = request.ExplicitlySpecifiedToolsVersion ?? request.ProjectInstance.ToolsVersion ?? BuildManager.OngoingBuildParameters.DefaultToolsVersion;
var outputs = new Dictionary <string, string> ();
engine.BuildProject(() => is_canceled, BuildResult, request.ProjectInstance, request.TargetNames, BuildManager.OngoingBuildParameters.GlobalProperties, outputs, toolsVersion);
} catch (Exception ex) {
BuildResult.Exception = ex;
BuildResult.OverallResult = BuildResultCode.Failure;
}
is_completed = true;
if (callback != null)
{
callback(this);
}
wait_handle.Set();
return(BuildResult);
}
public override bool Execute()
{
var logger = new Logger(Log);
var sandbox = BuildEngine4.GetRegisteredTaskObject(BuildEngine.ProjectFileOfTaskNode, RegisteredTaskObjectLifetime.Build) as Sanbox;
if (sandbox == null)
{
return(true);
}
try
{
sandbox.Dispose();
BuildEngine4.UnregisterTaskObject(BuildEngine.ProjectFileOfTaskNode, RegisteredTaskObjectLifetime.Build);
}
catch (Exception e)
{
logger.Error($"Failure cleanup task failed. Details: {e.GetBaseException().Message}");
}
return(!Log.HasLoggedErrors);
}
public override bool Execute()
{
if (LaunchProfiles == null || UserFile == null || FlagFile == null)
{
return(true);
}
try
{
if (BuildEngine4.GetRegisteredTaskObject(nameof(ActiveDocumentMonitor), RegisteredTaskObjectLifetime.AppDomain) is not ActiveDocumentMonitor monitor)
{
if (WindowsInterop.GetServiceProvider() is IServiceProvider services)
{
BuildEngine4.RegisterTaskObject(nameof(ActiveDocumentMonitor),
new ActiveDocumentMonitor(LaunchProfiles, UserFile, FlagFile, services),
RegisteredTaskObjectLifetime.AppDomain, false);
}
}
else
{
// NOTE: this means we only support ONE project/launchProfiles per IDE.
monitor.Refresh(LaunchProfiles, UserFile, FlagFile);
}
}
public override bool Execute()
{
var entry = (RegisterObject)BuildEngine4.GetRegisteredTaskObject(RegisterObject.CacheKey, RegisteredTaskObjectLifetime.Build);
return(true);
}
void AddEnvironment()
{
bool usesMonoAOT = false;
bool usesAssemblyPreload = EnablePreloadAssembliesDefault;
bool brokenExceptionTransitions = false;
var environmentVariables = new Dictionary <string, string> (StringComparer.Ordinal);
var systemProperties = new Dictionary <string, string> (StringComparer.Ordinal);
if (!Enum.TryParse(PackageNamingPolicy, out PackageNamingPolicy pnp))
{
pnp = PackageNamingPolicyEnum.LowercaseCrc64;
}
AotMode aotMode = AotMode.None;
if (!string.IsNullOrEmpty(AndroidAotMode) && Aot.GetAndroidAotMode(AndroidAotMode, out aotMode) && aotMode != AotMode.None)
{
usesMonoAOT = true;
}
bool haveLogLevel = false;
bool haveMonoDebug = false;
bool havebuildId = false;
bool haveHttpMessageHandler = false;
bool haveTlsProvider = false;
bool haveMonoGCParams = false;
SequencePointsMode sequencePointsMode;
if (!Aot.TryGetSequencePointsMode(AndroidSequencePointsMode, out sequencePointsMode))
{
sequencePointsMode = SequencePointsMode.None;
}
foreach (ITaskItem env in Environments ?? new TaskItem[0])
{
foreach (string line in File.ReadLines(env.ItemSpec))
{
var lineToWrite = line;
if (lineToWrite.StartsWith("MONO_LOG_LEVEL=", StringComparison.Ordinal))
{
haveLogLevel = true;
}
if (lineToWrite.StartsWith("MONO_GC_PARAMS=", StringComparison.Ordinal))
{
haveMonoGCParams = true;
}
if (lineToWrite.StartsWith("XAMARIN_BUILD_ID=", StringComparison.Ordinal))
{
havebuildId = true;
}
if (lineToWrite.StartsWith("MONO_DEBUG=", StringComparison.Ordinal))
{
haveMonoDebug = true;
if (sequencePointsMode != SequencePointsMode.None && !lineToWrite.Contains("gen-compact-seq-points"))
{
lineToWrite = line + ",gen-compact-seq-points";
}
}
if (lineToWrite.StartsWith("XA_HTTP_CLIENT_HANDLER_TYPE=", StringComparison.Ordinal))
{
haveHttpMessageHandler = true;
}
if (lineToWrite.StartsWith("XA_TLS_PROVIDER=", StringComparison.Ordinal))
{
haveTlsProvider = true;
}
if (lineToWrite.StartsWith("mono.enable_assembly_preload=", StringComparison.Ordinal))
{
int idx = lineToWrite.IndexOf('=');
uint val;
if (idx < lineToWrite.Length - 1 && UInt32.TryParse(lineToWrite.Substring(idx + 1), out val))
{
usesAssemblyPreload = idx == 1;
}
continue;
}
if (lineToWrite.StartsWith("XA_BROKEN_EXCEPTION_TRANSITIONS="))
{
brokenExceptionTransitions = true;
continue;
}
AddEnvironmentVariableLine(lineToWrite);
}
}
if (_Debug && !haveLogLevel)
{
AddEnvironmentVariable(defaultLogLevel[0], defaultLogLevel[1]);
}
if (sequencePointsMode != SequencePointsMode.None && !haveMonoDebug)
{
AddEnvironmentVariable(defaultMonoDebug[0], defaultMonoDebug[1]);
}
if (!havebuildId)
{
AddEnvironmentVariable("XAMARIN_BUILD_ID", BuildId);
}
if (!haveHttpMessageHandler)
{
if (HttpClientHandlerType == null)
{
AddEnvironmentVariable(defaultHttpMessageHandler[0], defaultHttpMessageHandler[1]);
}
else
{
AddEnvironmentVariable("XA_HTTP_CLIENT_HANDLER_TYPE", HttpClientHandlerType.Trim());
}
}
if (!haveTlsProvider)
{
if (TlsProvider == null)
{
AddEnvironmentVariable(defaultTlsProvider[0], defaultTlsProvider[1]);
}
else
{
AddEnvironmentVariable("XA_TLS_PROVIDER", TlsProvider.Trim());
}
}
if (!haveMonoGCParams)
{
if (EnableSGenConcurrent)
{
AddEnvironmentVariable("MONO_GC_PARAMS", "major=marksweep-conc");
}
else
{
AddEnvironmentVariable("MONO_GC_PARAMS", "major=marksweep");
}
}
global::Android.Runtime.BoundExceptionType boundExceptionType;
if (String.IsNullOrEmpty(BoundExceptionType) || String.Compare(BoundExceptionType, "System", StringComparison.OrdinalIgnoreCase) == 0)
{
boundExceptionType = global::Android.Runtime.BoundExceptionType.System;
}
else if (String.Compare(BoundExceptionType, "Java", StringComparison.OrdinalIgnoreCase) == 0)
{
boundExceptionType = global::Android.Runtime.BoundExceptionType.Java;
}
else
{
throw new InvalidOperationException($"Unsupported BoundExceptionType value '{BoundExceptionType}'");
}
var appConfState = BuildEngine4.GetRegisteredTaskObjectAssemblyLocal <ApplicationConfigTaskState> (ApplicationConfigTaskState.RegisterTaskObjectKey, RegisteredTaskObjectLifetime.Build);
foreach (string abi in SupportedAbis)
{
NativeAssemblerTargetProvider asmTargetProvider = GetAssemblyTargetProvider(abi);
string baseAsmFilePath = Path.Combine(EnvironmentOutputDirectory, $"environment.{abi.ToLowerInvariant ()}");
string asmFilePath = $"{baseAsmFilePath}.s";
var asmgen = new ApplicationConfigNativeAssemblyGenerator(asmTargetProvider, baseAsmFilePath, environmentVariables, systemProperties)
{
IsBundledApp = IsBundledApplication,
UsesMonoAOT = usesMonoAOT,
UsesMonoLLVM = EnableLLVM,
UsesAssemblyPreload = usesAssemblyPreload,
MonoAOTMode = aotMode.ToString().ToLowerInvariant(),
AndroidPackageName = AndroidPackageName,
BrokenExceptionTransitions = brokenExceptionTransitions,
PackageNamingPolicy = pnp,
BoundExceptionType = boundExceptionType,
InstantRunEnabled = InstantRunEnabled,
JniAddNativeMethodRegistrationAttributePresent = appConfState != null ? appConfState.JniAddNativeMethodRegistrationAttributePresent : false,
};
using (var sw = MemoryStreamPool.Shared.CreateStreamWriter()) {
asmgen.Write(sw);
sw.Flush();
Files.CopyIfStreamChanged(sw.BaseStream, asmFilePath);
}
}
void AddEnvironmentVariable(string name, string value)
{
if (Char.IsUpper(name [0]) || !Char.IsLetter(name [0]))
{
environmentVariables [ValidAssemblerString(name)] = ValidAssemblerString(value);
}
else
{
systemProperties [ValidAssemblerString(name)] = ValidAssemblerString(value);
}
}
void AddEnvironmentVariableLine(string l)
{
string line = l?.Trim();
if (String.IsNullOrEmpty(line) || line [0] == '#')
{
return;
}
string[] nv = line.Split(new char[] { '=' }, 2);
AddEnvironmentVariable(nv[0].Trim(), nv.Length < 2 ? String.Empty : nv[1].Trim());
}
string ValidAssemblerString(string s)
{
return(s.Replace("\"", "\\\""));
}
}
public override bool RunTask()
{
if (InputAssemblies == null)
{
return(true);
}
var output = new List <ITaskItem> (InputAssemblies.Length);
foreach (var assemblyItem in InputAssemblies)
{
if (!File.Exists(assemblyItem.ItemSpec))
{
Log.LogDebugMessage($"Skipping non-existent dependency '{assemblyItem.ItemSpec}'.");
continue;
}
using (var pe = new PEReader(File.OpenRead(assemblyItem.ItemSpec))) {
var reader = pe.GetMetadataReader();
// Check in-memory cache
var module = reader.GetModuleDefinition();
var key = (nameof(FilterAssemblies), reader.GetGuid(module.Mvid));
var value = BuildEngine4.GetRegisteredTaskObject(key, Lifetime);
if (value is bool isMonoAndroidAssembly)
{
if (isMonoAndroidAssembly)
{
Log.LogDebugMessage($"Cached: {assemblyItem.ItemSpec}");
output.Add(assemblyItem);
}
continue;
}
// Check assembly definition
var assemblyDefinition = reader.GetAssemblyDefinition();
var targetFrameworkIdentifier = GetTargetFrameworkIdentifier(assemblyDefinition, reader);
if (string.Compare(targetFrameworkIdentifier, TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) == 0)
{
output.Add(assemblyItem);
BuildEngine4.RegisterTaskObject(key, true, Lifetime, AllowEarlyCollection);
continue;
}
// Fallback to looking for a Mono.Android reference
if (MonoAndroidHelper.HasMonoAndroidReference(reader))
{
Log.LogDebugMessage($"Mono.Android reference found: {assemblyItem.ItemSpec}");
output.Add(assemblyItem);
BuildEngine4.RegisterTaskObject(key, true, Lifetime, AllowEarlyCollection);
continue;
}
// Fallback to looking for *.jar or __Android EmbeddedResource files
if (HasEmbeddedResource(reader))
{
Log.LogDebugMessage($"EmbeddedResource found: {assemblyItem.ItemSpec}");
output.Add(assemblyItem);
BuildEngine4.RegisterTaskObject(key, true, Lifetime, AllowEarlyCollection);
continue;
}
// Not a MonoAndroid assembly, store false
BuildEngine4.RegisterTaskObject(key, false, Lifetime, AllowEarlyCollection);
}
}
OutputAssemblies = output.ToArray();
return(!Log.HasLoggedErrors);
}
void GenerateCompressedAssemblySources()
{
if (Debug || !EnableCompression)
{
Generate(null);
return;
}
var assemblies = new SortedDictionary <string, CompressedAssemblyInfo> (StringComparer.Ordinal);
foreach (ITaskItem assembly in ResolvedAssemblies)
{
if (bool.TryParse(assembly.GetMetadata("AndroidSkipAddToPackage"), out bool value) && value)
{
continue;
}
if (assemblies.ContainsKey(assembly.ItemSpec))
{
continue;
}
var fi = new FileInfo(assembly.ItemSpec);
if (!fi.Exists)
{
Log.LogError($"Assembly {assembly.ItemSpec} does not exist");
continue;
}
assemblies.Add(CompressedAssemblyInfo.GetDictionaryKey(assembly),
new CompressedAssemblyInfo(checked ((uint)fi.Length)));
}
uint index = 0;
foreach (var kvp in assemblies)
{
kvp.Value.DescriptorIndex = index++;
}
string key = CompressedAssemblyInfo.GetKey(ProjectFullPath);
Log.LogDebugMessage($"Storing compression assemblies info with key '{key}'");
BuildEngine4.RegisterTaskObjectAssemblyLocal(key, assemblies, RegisteredTaskObjectLifetime.Build);
Generate(assemblies);
void Generate(IDictionary <string, CompressedAssemblyInfo> dict)
{
foreach (string abi in SupportedAbis)
{
NativeAssemblerTargetProvider asmTargetProvider = GeneratePackageManagerJava.GetAssemblyTargetProvider(abi);
string baseAsmFilePath = Path.Combine(EnvironmentOutputDirectory, $"compressed_assemblies.{abi.ToLowerInvariant ()}");
string asmFilePath = $"{baseAsmFilePath}.s";
var asmgen = new CompressedAssembliesNativeAssemblyGenerator(dict, asmTargetProvider, baseAsmFilePath);
using (var sw = MemoryStreamPool.Shared.CreateStreamWriter()) {
asmgen.Write(sw);
sw.Flush();
if (MonoAndroidHelper.CopyIfStreamChanged(sw.BaseStream, asmFilePath))
{
Log.LogDebugMessage($"File {asmFilePath} was regenerated");
}
}
}
}
}
