public static bool GetAndroidAotMode(string androidAotMode, out AotMode aotMode)
{
aotMode = AotMode.Normal;
switch ((androidAotMode ?? string.Empty).ToLowerInvariant().Trim())
{
case "none":
aotMode = AotMode.None;
return(true);
case "normal":
aotMode = AotMode.Normal;
return(true);
case "hybrid":
aotMode = AotMode.Hybrid;
return(true);
case "full":
aotMode = AotMode.Full;
return(true);
}
return(false);
}
public static bool GetAndroidAotMode(string androidAotMode, out AotMode aotMode)
{
aotMode = AotMode.Normal;
switch ((androidAotMode ?? string.Empty).ToLowerInvariant().Trim())
{
case "":
case "none":
aotMode = AotMode.None;
return(true);
case "normal":
aotMode = AotMode.Normal;
return(true);
case "hybrid":
aotMode = AotMode.Hybrid;
return(true);
case "full":
aotMode = AotMode.Full;
return(true);
case "interpreter":
aotMode = AotMode.Interp;
return(true); // We don't do anything here for this mode, this is just to set the flag for the XA
// runtime to initialize Mono in the inrepreter "AOT" mode.
}
return(false);
}
protected override string GenerateCommandLineCommands()
{
var args = new CommandLineArgumentBuilder();
bool msym;
args.AddLine("/verbose");
if (Debug)
{
args.AddLine("/debug");
}
if (!string.IsNullOrEmpty(OutputPath))
{
args.AddQuotedLine("/output:" + Path.GetFullPath(OutputPath));
}
if (!string.IsNullOrEmpty(ApplicationName))
{
args.AddQuotedLine("/name:" + ApplicationName);
}
if (TargetFrameworkIdentifier == "Xamarin.Mac")
{
args.AddLine("/profile:Xamarin.Mac,Version=v2.0,Profile=Mobile");
}
else if (UseXamMacFullFramework)
{
args.AddLine($"/profile:Xamarin.Mac,Version={TargetFrameworkVersion},Profile=Full");
}
else
{
args.AddLine($"/profile:Xamarin.Mac,Version={TargetFrameworkVersion},Profile=System");
}
XamMacArch arch;
if (!Enum.TryParse(Architecture, true, out arch))
{
arch = XamMacArch.Default;
}
if (arch == XamMacArch.Default)
{
arch = XamMacArch.x86_64;
}
if (arch.HasFlag(XamMacArch.i386))
{
args.AddLine("/arch:i386");
}
if (arch.HasFlag(XamMacArch.x86_64))
{
args.AddLine("/arch:x86_64");
}
if (!string.IsNullOrEmpty(ArchiveSymbols) && bool.TryParse(ArchiveSymbols.Trim(), out msym))
{
args.AddLine("--msym:" + (msym ? "yes" : "no"));
}
args.AddLine(string.Format("--http-message-handler={0}", HttpClientHandler));
if (AppManifest != null)
{
try {
var plist = PDictionary.FromFile(AppManifest.ItemSpec);
PString v;
string minimumDeploymentTarget;
if (!plist.TryGetValue(ManifestKeys.LSMinimumSystemVersion, out v) || string.IsNullOrEmpty(v.Value))
{
minimumDeploymentTarget = SdkVersion;
}
else
{
minimumDeploymentTarget = v.Value;
}
args.AddLine(string.Format("/minos={0}", minimumDeploymentTarget));
}
catch (Exception ex) {
Log.LogWarning(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, "Error loading '{0}': {1}", AppManifest.ItemSpec, ex.Message);
}
}
if (Profiling)
{
args.AddLine("/profiling");
}
if (EnableSGenConc)
{
args.AddLine("/sgen-conc");
}
switch ((LinkMode ?? string.Empty).ToLower())
{
case "full":
break;
case "sdkonly":
args.AddLine("/linksdkonly");
break;
case "platform":
args.AddLine("/linkplatform");
break;
default:
args.AddLine("/nolink");
break;
}
if (!string.IsNullOrEmpty(AotMode) && AotMode != "None")
{
var aot = $"--aot:{AotMode.ToLower ()}";
if (HybridAOT)
{
aot += "|hybrid";
}
if (!string.IsNullOrEmpty(ExplicitAotAssemblies))
{
aot += $",{ExplicitAotAssemblies}";
}
args.AddLine(aot);
}
if (!string.IsNullOrEmpty(I18n))
{
args.AddQuotedLine("/i18n:" + I18n);
}
if (ExplicitReferences != null)
{
foreach (var asm in ExplicitReferences)
{
args.AddQuotedLine("/assembly:" + Path.GetFullPath(asm.ItemSpec));
}
}
if (!string.IsNullOrEmpty(ApplicationAssembly.ItemSpec))
{
args.AddQuotedLine("/root-assembly:" + Path.GetFullPath(ApplicationAssembly.ItemSpec));
}
if (NativeReferences != null)
{
foreach (var nr in NativeReferences)
{
args.AddQuotedLine("/native-reference:" + Path.GetFullPath(nr.ItemSpec));
}
}
if (IsAppExtension)
{
args.AddQuotedLine("/extension");
}
if (IsXPCService)
{
args.AddQuotedLine("/xpc");
}
args.AddQuotedLine("/sdkroot:" + SdkRoot);
if (!string.IsNullOrEmpty(IntermediateOutputPath))
{
Directory.CreateDirectory(IntermediateOutputPath);
args.AddQuotedLine("--cache:" + Path.GetFullPath(IntermediateOutputPath));
}
// Generate a response file
var responseFile = Path.GetFullPath(ResponseFilePath);
if (File.Exists(responseFile))
{
File.Delete(responseFile);
}
try {
using (var fs = File.Create(responseFile)) {
using (var writer = new StreamWriter(fs))
writer.Write(args);
}
} catch (Exception ex) {
Log.LogWarning("Failed to create response file '{0}': {1}", responseFile, ex);
}
// Some arguments can not safely go in the response file and are
// added separately. They must go _after_ the response file
// as they may override options passed in the response file
var actualArgs = new CommandLineArgumentBuilder();
actualArgs.AddQuoted($"@{responseFile}");
if (!string.IsNullOrWhiteSpace(ExtraArguments))
{
actualArgs.Add(ExtraArguments);
}
return(actualArgs.ToString());
}
protected override string GenerateCommandLineCommands()
{
var args = GenerateCommandLineArguments();
if (!string.IsNullOrEmpty(OutputPath))
{
args.AddQuotedLine("/output:" + Path.GetFullPath(OutputPath));
}
if (!string.IsNullOrEmpty(ApplicationName))
{
args.AddQuotedLine("/name:" + ApplicationName);
}
XamMacArch arch;
if (!Enum.TryParse(Architecture, true, out arch))
{
arch = XamMacArch.Default;
}
if (arch == XamMacArch.Default)
{
arch = XamMacArch.x86_64;
}
if (arch.HasFlag(XamMacArch.i386))
{
args.AddLine("/arch:i386");
}
if (arch.HasFlag(XamMacArch.x86_64))
{
args.AddLine("/arch:x86_64");
}
switch ((LinkMode ?? string.Empty).ToLower())
{
case "full":
break;
case "sdkonly":
args.AddLine("/linksdkonly");
break;
case "platform":
args.AddLine("/linkplatform");
break;
default:
args.AddLine("/nolink");
break;
}
if (!string.IsNullOrEmpty(AotMode) && AotMode != "None")
{
var aot = $"--aot:{AotMode.ToLower ()}";
if (HybridAOT)
{
aot += "|hybrid";
}
if (!string.IsNullOrEmpty(ExplicitAotAssemblies))
{
aot += $",{ExplicitAotAssemblies}";
}
args.AddLine(aot);
}
if (References != null)
{
foreach (var asm in References)
{
args.AddQuotedLine("/reference:" + Path.GetFullPath(asm.ItemSpec));
}
}
if (NativeReferences != null)
{
foreach (var nr in NativeReferences)
{
args.AddQuotedLine("/native-reference:" + Path.GetFullPath(nr.ItemSpec));
}
}
if (IsAppExtension)
{
args.AddQuotedLine("/extension");
}
if (IsXPCService)
{
args.AddQuotedLine("/xpc");
}
return(CreateResponseFile(args, ExtraArgs == null ? null : CommandLineArgumentBuilder.Parse(ExtraArgs)));
}
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("\"", "\\\""));
}
}
protected override string GenerateCommandLineCommands()
{
var args = GenerateCommandLineArguments();
if (!string.IsNullOrEmpty(OutputPath))
{
args.AddQuotedLine("/output:" + Path.GetFullPath(OutputPath));
}
if (!string.IsNullOrEmpty(ApplicationName))
{
args.AddQuotedLine("/name:" + ApplicationName);
}
XamMacArch arch;
if (!Enum.TryParse(Architecture, true, out arch))
{
arch = XamMacArch.Default;
}
if (arch == XamMacArch.Default)
{
arch = XamMacArch.x86_64;
}
if (arch.HasFlag(XamMacArch.i386))
{
args.AddLine("/arch:i386");
}
if (arch.HasFlag(XamMacArch.x86_64))
{
args.AddLine("/arch:x86_64");
}
if (AppManifest != null)
{
try {
var plist = PDictionary.FromFile(AppManifest.ItemSpec);
PString v;
string minimumDeploymentTarget;
if (!plist.TryGetValue(ManifestKeys.LSMinimumSystemVersion, out v) || string.IsNullOrEmpty(v.Value))
{
minimumDeploymentTarget = SdkVersion;
}
else
{
minimumDeploymentTarget = v.Value;
}
args.AddLine(string.Format("/minos={0}", minimumDeploymentTarget));
}
catch (Exception ex) {
Log.LogWarning(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, MSBStrings.E0010, AppManifest.ItemSpec, ex.Message);
}
}
switch ((LinkMode ?? string.Empty).ToLower())
{
case "full":
break;
case "sdkonly":
args.AddLine("/linksdkonly");
break;
case "platform":
args.AddLine("/linkplatform");
break;
default:
args.AddLine("/nolink");
break;
}
if (!string.IsNullOrEmpty(AotMode) && AotMode != "None")
{
var aot = $"--aot:{AotMode.ToLower ()}";
if (HybridAOT)
{
aot += "|hybrid";
}
if (!string.IsNullOrEmpty(ExplicitAotAssemblies))
{
aot += $",{ExplicitAotAssemblies}";
}
args.AddLine(aot);
}
if (References != null)
{
foreach (var asm in References)
{
args.AddQuotedLine("/assembly:" + Path.GetFullPath(asm.ItemSpec));
}
}
if (NativeReferences != null)
{
foreach (var nr in NativeReferences)
{
args.AddQuotedLine("/native-reference:" + Path.GetFullPath(nr.ItemSpec));
}
}
if (IsAppExtension)
{
args.AddQuotedLine("/extension");
}
if (IsXPCService)
{
args.AddQuotedLine("/xpc");
}
return(CreateResponseFile(args, ExtraArgs == null ? null : CommandLineArgumentBuilder.Parse(ExtraArgs)));
}
public static bool GetAndroidAotMode(string androidAotMode, out AotMode aotMode)
{
aotMode = AotMode.Normal;
switch ((androidAotMode ?? string.Empty).ToLowerInvariant().Trim())
{
case "normal":
aotMode = AotMode.Normal;
return true;
case "hybrid":
aotMode = AotMode.Hybrid;
return true;
case "full":
aotMode = AotMode.Full;
return true;
}
return false;
}
