public override bool RunTask()
{
var dependencies = new List <ITaskItem> ();
var targetApiLevel = MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion);
var manifestApiLevel = DefaultMinSDKVersion;
if (File.Exists(ManifestFile.ItemSpec))
{
var manifest = AndroidAppManifest.Load(ManifestFile.ItemSpec, MonoAndroidHelper.SupportedVersions);
manifestApiLevel = manifest.TargetSdkVersion ?? manifest.MinSdkVersion ?? DefaultMinSDKVersion;
}
var sdkVersion = Math.Max(targetApiLevel.Value, manifestApiLevel);
dependencies.Add(CreateAndroidDependency($"platforms/android-{sdkVersion}", $""));
dependencies.Add(CreateAndroidDependency($"build-tools/{BuildToolsVersion}", BuildToolsVersion));
if (!string.IsNullOrEmpty(PlatformToolsVersion))
{
dependencies.Add(CreateAndroidDependency("platform-tools", PlatformToolsVersion));
}
if (!string.IsNullOrEmpty(CommandLineToolsVersion))
{
dependencies.Add(CreateAndroidDependency($"cmdline-tools/{CommandLineToolsVersion}", CommandLineToolsVersion));
}
if (!string.IsNullOrEmpty(ToolsVersion))
{
dependencies.Add(CreateAndroidDependency("tools", ToolsVersion));
}
if (!string.IsNullOrEmpty(NdkVersion) && NdkRequired)
{
dependencies.Add(CreateAndroidDependency("ndk-bundle", NdkVersion));
}
Dependencies = dependencies.ToArray();
return(!Log.HasLoggedErrors);
}
public override bool Execute()
{
BuildId = buildId.ToString();
Log.LogDebugMessage(" [Output] BuildId: {0}", BuildId);
var shared_runtime = string.Compare(UseSharedRuntime, "true", true) == 0;
var doc = AndroidAppManifest.Load(Manifest, MonoAndroidHelper.SupportedVersions);
int minApiVersion = doc.MinSdkVersion == null ? 4 : (int)doc.MinSdkVersion;
// We need to include any special assemblies in the Assemblies list
var assemblies = ResolvedUserAssemblies.Select(p => p.ItemSpec)
.Concat(MonoAndroidHelper.GetFrameworkAssembliesToTreatAsUserAssemblies(ResolvedAssemblies))
.ToList();
var mainFileName = Path.GetFileName(MainAssembly);
Func <string, string, bool> fileNameEq = (a, b) => a.Equals(b, StringComparison.OrdinalIgnoreCase);
assemblies = assemblies.Where(a => fileNameEq(a, mainFileName)).Concat(assemblies.Where(a => !fileNameEq(a, mainFileName))).ToList();
using (var stream = new MemoryStream())
using (var pkgmgr = new StreamWriter(stream)) {
pkgmgr.WriteLine("package mono;");
// Write all the user assemblies
pkgmgr.WriteLine("public class MonoPackageManager_Resources {");
pkgmgr.WriteLine("\tpublic static final String[] Assemblies = new String[]{");
pkgmgr.WriteLine("\t\t/* We need to ensure that \"{0}\" comes first in this list. */", mainFileName);
foreach (var assembly in assemblies)
{
pkgmgr.WriteLine("\t\t\"" + Path.GetFileName(assembly) + "\",");
}
// Write the assembly dependencies
pkgmgr.WriteLine("\t};");
pkgmgr.WriteLine("\tpublic static final String[] Dependencies = new String[]{");
//foreach (var assembly in assemblies.Except (args.Assemblies)) {
// if (args.SharedRuntime && !Toolbox.IsInSharedRuntime (assembly))
// pkgmgr.WriteLine ("\t\t\"" + Path.GetFileName (assembly) + "\",");
//}
pkgmgr.WriteLine("\t};");
// Write the platform api apk we need
pkgmgr.WriteLine("\tpublic static final String ApiPackageName = {0};", shared_runtime
? string.Format("\"Mono.Android.Platform.ApiLevel_{0}\"",
MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion))
: "null");
pkgmgr.WriteLine("}");
pkgmgr.Flush();
// Only copy to the real location if the contents actually changed
var dest = Path.GetFullPath(Path.Combine(OutputDirectory, "MonoPackageManager_Resources.java"));
MonoAndroidHelper.CopyIfStreamChanged(stream, dest);
}
AddEnvironment();
return(!Log.HasLoggedErrors);
}
protected override string GenerateCommandLineCommands()
{
var cmd = new CommandLineBuilder();
var manifest = AndroidAppManifest.Load(ManifestFile.ItemSpec, MonoAndroidHelper.SupportedVersions);
int minSdk = MonoAndroidHelper.SupportedVersions.MinStableVersion.ApiLevel;
int maxSdk = MonoAndroidHelper.SupportedVersions.MaxStableVersion.ApiLevel;
if (manifest.MinSdkVersion.HasValue)
{
minSdk = manifest.MinSdkVersion.Value;
}
if (manifest.TargetSdkVersion.HasValue)
{
maxSdk = manifest.TargetSdkVersion.Value;
}
cmd.AppendSwitch("sign");
cmd.AppendSwitchIfNotNull("--ks ", KeyStore);
cmd.AppendSwitchIfNotNull("--ks-pass pass:"******"--ks-key-alias ", KeyAlias);
cmd.AppendSwitchIfNotNull("--key-pass pass:"******"--min-sdk-version ", minSdk.ToString());
cmd.AppendSwitchIfNotNull("--max-sdk-version ", maxSdk.ToString());
cmd.AppendSwitchIfNotNull("--in ", ApkToSign);
if (!string.IsNullOrEmpty(AdditionalArguments))
{
cmd.AppendSwitch(AdditionalArguments);
}
return(cmd.ToString());
}
protected override string SetAppBundleId(string manifest, string packageName)
{
var appManifest = AndroidAppManifest.Load(XDocument.Parse(manifest), AndroidVersions);
appManifest.PackageName = packageName;
return(appManifest.Document.ToString());
}
protected override void ProcessManifest(string path, string buildNumber)
{
var androidManifest = AndroidAppManifest.Load(path, new AndroidVersions(ReferenceAssemblyPaths));
androidManifest.VersionCode = buildNumber;
androidManifest.VersionName = $"{SanitizeVersion(androidManifest.VersionName)}.{buildNumber}";
androidManifest.WriteToFile(path);
}
protected override void ProcessManifest(string path, string outputPath, string buildNumber)
{
var androidManifest = AndroidAppManifest.Load(path, new AndroidVersions(AndroidVersions.KnownVersions));
androidManifest.VersionCode = buildNumber;
androidManifest.VersionName = $"{SanitizeVersion(androidManifest.VersionName)}.{buildNumber}";
androidManifest.WriteToFile(outputPath);
}
public override bool RunTask()
{
var manifest = AndroidAppManifest.Load(ManifestFile, MonoAndroidHelper.SupportedVersions);
ActivityName = manifest.GetLaunchableUserActivityName();
return(!Log.HasLoggedErrors);
}
protected override string GenerateCommandLineCommands()
{
// Running command: C:\Program Files (x86)\Java\jdk1.6.0_20\bin\java.exe
// "-jar" "C:\Program Files (x86)\Android\android-sdk-windows\platform-tools\jill.jar"
// "--output-dex" "bin\classes"
// "-classpath" "C:\Users\Jonathan\Documents\Visual Studio 2010\Projects\AndroidMSBuildTest\AndroidMSBuildTest\obj\Debug\android\bin\mono.android.jar"
// "@C:\Users\Jonathan\AppData\Local\Temp\tmp79c4ac38.tmp"
//var android_dir = MonoDroid.MonoDroidSdk.GetAndroidProfileDirectory (TargetFrameworkDirectory);
var doc = AndroidAppManifest.Load(ManifestFile, MonoAndroidHelper.SupportedVersions);
int minApiVersion = doc.MinSdkVersion == null ? 4 : (int)doc.MinSdkVersion;
var cmd = new CommandLineBuilder();
// Add the JavaOptions if they are not null
// These could be any of the additional options
if (!string.IsNullOrEmpty(JavaOptions))
{
cmd.AppendSwitch(JavaOptions);
}
// Add the specific -XmxN to override the default heap size for the JVM
// N can be in the form of Nm or NGB (e.g 100m or 1GB )
cmd.AppendSwitchIfNotNull("-Xmx", JavaMaximumHeapSize);
cmd.AppendSwitchIfNotNull("-jar ", DesugarJarPath);
cmd.AppendSwitch("--bootclasspath_entry ");
cmd.AppendFileNameIfNotNull(JavaPlatformJarPath);
cmd.AppendSwitch("--min_sdk_version ");
cmd.AppendSwitch(minApiVersion.ToString());
//cmd.AppendSwitchIfNotNull ("-J-Dfile.encoding=", "UTF8");
if (!string.IsNullOrEmpty(DesugarExtraArguments))
{
cmd.AppendSwitch(DesugarExtraArguments); // it should contain "--dex".
}
var outputs = new List <string> ();
var md5 = System.Security.Cryptography.MD5.Create();
foreach (var jar in InputJars)
{
var output = Path.Combine(OutputDirectory, BitConverter.ToString(md5.ComputeHash(Encoding.UTF8.GetBytes(jar))) + Path.GetFileName(jar));
outputs.Add(output);
cmd.AppendSwitch("--input ");
cmd.AppendFileNameIfNotNull(jar);
cmd.AppendSwitch("--output ");
cmd.AppendFileNameIfNotNull(output);
}
OutputJars = outputs.ToArray();
return(cmd.ToString());
}
public void ParsePermissions()
{
var versions = new AndroidVersions(new AndroidVersion [0]);
var manifest = AndroidAppManifest.Load(GetTestAppManifest(), versions);
var permissions = manifest.AndroidPermissions.ToArray();
Assert.AreEqual(3, permissions.Length, "#1");
Assert.IsTrue(permissions.Contains("INTERNET"), "#2");
Assert.IsTrue(permissions.Contains("READ_CONTACTS"), "#3");
Assert.IsTrue(permissions.Contains("WRITE_CONTACTS"), "#4");
}
public void Load()
{
var versions = new AndroidVersions(new AndroidVersion [0]);
Assert.Throws <ArgumentNullException> (() => AndroidAppManifest.Load((string)null, versions));
Assert.Throws <ArgumentNullException> (() => AndroidAppManifest.Load("filename", null));
Assert.Throws <ArgumentNullException> (() => AndroidAppManifest.Load((XDocument)null, versions));
Assert.Throws <ArgumentNullException> (() => AndroidAppManifest.Load(GetTestAppManifest(), null));
Assert.Throws <ArgumentException> (() => AndroidAppManifest.Load(XDocument.Parse("<invalid-root/>"), versions));
}
public void CanGetAppTheme()
{
var versions = new AndroidVersions(new AndroidVersion [0]);
var doc = XDocument.Parse(@"
<manifest xmlns:android=""http://schemas.android.com/apk/res/android"" android:versionCode=""1"" android:versionName=""1.0"" package=""com.xamarin.Foo"">
<uses-sdk android:minSdkVersion=""8"" android:targetSdkVersion=""12"" />
<application android:label=""Foo"" android:icon=""@drawable/ic_icon"" android:theme=""@android:style/Theme.Material.Light"">
</application>
</manifest>" );
var manifest = AndroidAppManifest.Load(doc, versions);
Assert.AreEqual("@android:style/Theme.Material.Light", manifest.ApplicationTheme);
}
protected override string GenerateCommandLineCommands()
{
var cmd = new CommandLineBuilder();
var manifest = AndroidAppManifest.Load(ManifestFile.ItemSpec, MonoAndroidHelper.SupportedVersions);
int minSdk = MonoAndroidHelper.SupportedVersions.MinStableVersion.ApiLevel;
int maxSdk = MonoAndroidHelper.SupportedVersions.MaxStableVersion.ApiLevel;
if (manifest.MinSdkVersion.HasValue)
{
minSdk = manifest.MinSdkVersion.Value;
}
if (manifest.TargetSdkVersion.HasValue)
{
maxSdk = manifest.TargetSdkVersion.Value;
}
minSdk = Math.Min(minSdk, maxSdk);
cmd.AppendSwitchIfNotNull("-jar ", ApkSignerJar);
cmd.AppendSwitch("sign");
if (!string.IsNullOrEmpty(PlatformKey) && !string.IsNullOrEmpty(PlatformCert))
{
cmd.AppendSwitchIfNotNull("--key ", PlatformKey);
cmd.AppendSwitchIfNotNull("--cert ", PlatformCert);
}
else
{
cmd.AppendSwitchIfNotNull("--ks ", KeyStore);
AddStorePass(cmd, "--ks-pass", StorePass);
cmd.AppendSwitchIfNotNull("--ks-key-alias ", KeyAlias);
AddStorePass(cmd, "--key-pass", KeyPass);
}
cmd.AppendSwitchIfNotNull("--min-sdk-version ", minSdk.ToString());
cmd.AppendSwitchIfNotNull("--max-sdk-version ", maxSdk.ToString());
if (!string.IsNullOrEmpty(AdditionalArguments))
{
cmd.AppendSwitch(AdditionalArguments);
}
cmd.AppendSwitchIfNotNull(" ", Path.GetFullPath(ApkToSign));
return(cmd.ToString());
}
public void SetNewPermissions()
{
var versions = new AndroidVersions(new AndroidVersion [0]);
var manifest = AndroidAppManifest.Load(GetTestAppManifest(), versions);
manifest.SetAndroidPermissions(new [] { "FOO" });
var sb = new StringBuilder();
using (var writer = XmlWriter.Create(sb)) {
manifest.Write(writer);
}
manifest = AndroidAppManifest.Load(XDocument.Parse(sb.ToString()), versions);
Assert.AreEqual(1, manifest.AndroidPermissions.Count(), "#1");
Assert.AreEqual("FOO", manifest.AndroidPermissions.ElementAt(0));
}
public async override System.Threading.Tasks.Task RunTaskAsync()
{
if (LibraryTextFiles == null || LibraryTextFiles.Length == 0)
{
return;
}
// Load the "main" R.txt file into a dictionary
main_r_txt = Path.GetFullPath(ResourceSymbolsTextFile);
r_txt_mapping = new Dictionary <string, string> ();
using (var reader = File.OpenText(main_r_txt)) {
foreach (var line in ParseFile(reader))
{
var key = line [Index.Class] + " " + line [Index.Name];
r_txt_mapping [key] = line [Index.Value];
}
}
Directory.CreateDirectory(OutputDirectory);
output_directory = Path.GetFullPath(OutputDirectory);
var libraries = new Dictionary <string, Package> ();
for (int i = 0; i < LibraryTextFiles.Length; i++)
{
var libraryTextFile = LibraryTextFiles [i];
var manifestFile = ManifestFiles [i];
if (!File.Exists(manifestFile))
{
LogDebugMessage($"Skipping, AndroidManifest.xml does not exist: {manifestFile}");
continue;
}
var manifest = AndroidAppManifest.Load(Path.GetFullPath(manifestFile), MonoAndroidHelper.SupportedVersions);
var packageName = manifest.PackageName;
if (!libraries.TryGetValue(packageName, out Package library))
{
libraries.Add(packageName, library = new Package {
Name = packageName,
});
}
library.TextFiles.Add(Path.GetFullPath(libraryTextFile));
}
await this.WhenAll(libraries.Values, GenerateJava);
}
public void CanParseNonNumericSdkVersion()
{
var versions = new AndroidVersions(new AndroidVersion [0]);
var doc = XDocument.Parse(@"
<manifest xmlns:android=""http://schemas.android.com/apk/res/android"" android:versionCode=""1"" android:versionName=""1.0"" package=""com.xamarin.Foo"">
<uses-sdk android:minSdkVersion=""L"" android:targetSdkVersion=""L"" />
<application android:label=""Foo"" android:icon=""@drawable/ic_icon"">
</application>
</manifest>" );
var manifest = AndroidAppManifest.Load(doc, versions);
var mininum = manifest.MinSdkVersion;
var target = manifest.TargetSdkVersion;
Assert.IsTrue(mininum.HasValue);
Assert.IsTrue(target.HasValue);
Assert.AreEqual(21, mininum.Value);
Assert.AreEqual(21, target.Value);
}
public override bool RunTask()
{
var androidNs = AndroidAppManifest.AndroidXNamespace;
var manifest = AndroidAppManifest.Load(ManifestFile, MonoAndroidHelper.SupportedVersions);
var app = manifest.Document.Element("manifest")?.Element("application");
if (app != null)
{
string text = app.Attribute(androidNs + "extractNativeLibs")?.Value;
if (bool.TryParse(text, out bool value))
{
EmbeddedDSOsEnabled = !value;
}
text = app.Attribute(androidNs + "useEmbeddedDex")?.Value;
if (bool.TryParse(text, out value))
{
UseEmbeddedDex = value;
}
var libraries = new List <ITaskItem> ();
foreach (var uses_library in app.Elements("uses-library"))
{
var attribute = uses_library.Attribute(androidNs + "name");
if (attribute != null && !string.IsNullOrEmpty(attribute.Value))
{
var path = Path.Combine(AndroidSdkDirectory, "platforms", $"android-{AndroidApiLevel}", "optional", $"{attribute.Value}.jar");
if (File.Exists(path))
{
libraries.Add(new TaskItem(path));
}
else
{
Log.LogWarningForXmlNode("XA4218", ManifestFile, attribute, Properties.Resources.XA4218, path);
}
}
}
UsesLibraries = libraries.ToArray();
}
return(!Log.HasLoggedErrors);
}
public void EnsureMinAndTargetSdkVersionsAreReadIndependently()
{
// Regression test for https://bugzilla.xamarin.com/show_bug.cgi?id=21296
var versions = new AndroidVersions(new AndroidVersion [0]);
var doc = XDocument.Parse(@"
<manifest xmlns:android=""http://schemas.android.com/apk/res/android"" android:versionCode=""1"" android:versionName=""1.0"" package=""com.xamarin.Foo"">
<uses-sdk android:minSdkVersion=""8"" android:targetSdkVersion=""12"" />
<application android:label=""Foo"" android:icon=""@drawable/ic_icon"">
</application>
</manifest>" );
var manifest = AndroidAppManifest.Load(doc, versions);
var mininum = manifest.MinSdkVersion;
var target = manifest.TargetSdkVersion;
Assert.IsTrue(mininum.HasValue);
Assert.IsTrue(target.HasValue);
Assert.AreEqual(8, mininum.Value);
Assert.AreEqual(12, target.Value);
}
public override bool Execute()
{
Log.LogDebugMessage("GeneratePackageManagerJava Task");
Log.LogDebugMessage(" OutputDirectory: {0}", OutputDirectory);
Log.LogDebugMessage(" TargetFrameworkVersion: {0}", TargetFrameworkVersion);
Log.LogDebugMessage(" Manifest: {0}", Manifest);
Log.LogDebugMessage(" UseSharedRuntime: {0}", UseSharedRuntime);
Log.LogDebugMessage(" MainAssembly: {0}", MainAssembly);
Log.LogDebugTaskItems(" ResolvedAssemblies:", ResolvedAssemblies);
Log.LogDebugTaskItems(" ResolvedUserAssemblies:", ResolvedUserAssemblies);
var shared_runtime = string.Compare(UseSharedRuntime, "true", true) == 0;
var doc = AndroidAppManifest.Load(Manifest, MonoAndroidHelper.SupportedVersions);
int minApiVersion = doc.MinSdkVersion == null ? 4 : (int)doc.MinSdkVersion;
// We need to include any special assemblies in the Assemblies list
var assemblies = ResolvedUserAssemblies.Select(p => p.ItemSpec)
.Concat(MonoAndroidHelper.GetFrameworkAssembliesToTreatAsUserAssemblies(ResolvedAssemblies))
.ToList();
var mainFileName = Path.GetFileName(MainAssembly);
Func <string, string, bool> fileNameEq = (a, b) => a.Equals(b, StringComparison.OrdinalIgnoreCase);
assemblies = assemblies.Where(a => fileNameEq(a, mainFileName)).Concat(assemblies.Where(a => !fileNameEq(a, mainFileName))).ToList();
// Write first to a temporary file
var temp = Path.GetTempFileName();
using (var pkgmgr = File.CreateText(temp)) {
// Write the boilerplate from the MonoPackageManager.java resource
var packageManagerResource = minApiVersion < 9 ? "MonoPackageManager.api4.java" : "MonoPackageManager.java";
using (var template = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(packageManagerResource))) {
string line;
while ((line = template.ReadLine()) != null)
{
pkgmgr.WriteLine(line);
}
}
// Write all the user assemblies
pkgmgr.WriteLine("class MonoPackageManager_Resources {");
pkgmgr.WriteLine("\tpublic static final String[] Assemblies = new String[]{");
pkgmgr.WriteLine("\t\t/* We need to ensure that \"{0}\" comes first in this list. */", mainFileName);
foreach (var assembly in assemblies)
{
pkgmgr.WriteLine("\t\t\"" + Path.GetFileName(assembly) + "\",");
}
// Write the assembly dependencies
pkgmgr.WriteLine("\t};");
pkgmgr.WriteLine("\tpublic static final String[] Dependencies = new String[]{");
//foreach (var assembly in assemblies.Except (args.Assemblies)) {
// if (args.SharedRuntime && !Toolbox.IsInSharedRuntime (assembly))
// pkgmgr.WriteLine ("\t\t\"" + Path.GetFileName (assembly) + "\",");
//}
pkgmgr.WriteLine("\t};");
// Write the platform api apk we need
pkgmgr.WriteLine("\tpublic static final String ApiPackageName = {0};", shared_runtime
? string.Format("\"Mono.Android.Platform.ApiLevel_{0}\"",
MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion))
: "null");
pkgmgr.WriteLine("}");
}
// Only copy to the real location if the contents actually changed
var dest = Path.GetFullPath(Path.Combine(OutputDirectory, "MonoPackageManager.java"));
MonoAndroidHelper.CopyIfChanged(temp, dest);
try { File.Delete(temp); } catch (Exception) { }
try { File.Delete(temp); } catch (Exception) { }
return(!Log.HasLoggedErrors);
}
protected virtual CommandLineBuilder GetCommandLineBuilder()
{
var cmd = new CommandLineBuilder();
if (!string.IsNullOrEmpty(JavaOptions))
{
cmd.AppendSwitch(JavaOptions);
}
cmd.AppendSwitchIfNotNull("-Xmx", JavaMaximumHeapSize);
cmd.AppendSwitchIfNotNull("-classpath ", JarPath);
cmd.AppendSwitch(MainClass);
if (!string.IsNullOrEmpty(ExtraArguments))
{
cmd.AppendSwitch(ExtraArguments); // it should contain "--dex".
}
if (Debug)
{
cmd.AppendSwitch("--debug");
}
else
{
cmd.AppendSwitch("--release");
}
//NOTE: if this is blank, we can omit --min-api in this call
if (!string.IsNullOrEmpty(AndroidManifestFile))
{
var doc = AndroidAppManifest.Load(AndroidManifestFile, MonoAndroidHelper.SupportedVersions);
if (doc.MinSdkVersion.HasValue)
{
MinSdkVersion = doc.MinSdkVersion.Value;
cmd.AppendSwitchIfNotNull("--min-api ", MinSdkVersion.ToString());
}
}
if (!EnableDesugar)
{
cmd.AppendSwitch("--no-desugaring");
}
var injars = new List <string> ();
var libjars = new List <string> ();
if (AlternativeJarLibrariesToEmbed?.Length > 0)
{
Log.LogDebugMessage(" processing AlternativeJarLibrariesToEmbed...");
foreach (var jar in AlternativeJarLibrariesToEmbed)
{
injars.Add(jar.ItemSpec);
}
}
else if (JavaLibrariesToEmbed != null)
{
Log.LogDebugMessage(" processing ClassesZip, JavaLibrariesToEmbed...");
if (!string.IsNullOrEmpty(ClassesZip) && File.Exists(ClassesZip))
{
injars.Add(ClassesZip);
}
foreach (var jar in JavaLibrariesToEmbed)
{
injars.Add(jar.ItemSpec);
}
}
libjars.Add(JavaPlatformJarPath);
if (JavaLibrariesToReference != null)
{
foreach (var jar in JavaLibrariesToReference)
{
libjars.Add(jar.ItemSpec);
}
}
cmd.AppendSwitchIfNotNull("--output ", OutputDirectory);
foreach (var jar in libjars)
{
cmd.AppendSwitchIfNotNull("--lib ", jar);
}
foreach (var jar in injars)
{
cmd.AppendFileNameIfNotNull(jar);
}
return(cmd);
}
int GetNdkApiLevel(string androidNdkPath, string androidApiLevel, AndroidTargetArch arch)
{
var manifest = AndroidAppManifest.Load(ManifestFile.ItemSpec, MonoAndroidHelper.SupportedVersions);
int level;
if (manifest.MinSdkVersion.HasValue)
{
level = manifest.MinSdkVersion.Value;
}
else if (int.TryParse(androidApiLevel, out level))
{
// level already set
}
else
{
// Probably not ideal!
level = MonoAndroidHelper.SupportedVersions.MaxStableVersion.ApiLevel;
}
// Some Android API levels do not exist on the NDK level. Workaround this my mapping them to the
// most appropriate API level that does exist.
if (level == 6 || level == 7)
{
level = 5;
}
else if (level == 10)
{
level = 9;
}
else if (level == 11)
{
level = 12;
}
else if (level == 20)
{
level = 19;
}
else if (level == 22)
{
level = 21;
}
else if (level == 23)
{
level = 21;
}
// API levels below level 21 do not provide support for 64-bit architectures.
if (NdkUtil.IsNdk64BitArch(arch) && level < 21)
{
level = 21;
}
// We perform a downwards API level lookup search since we might not have hardcoded the correct API
// mapping above and we do not want to crash needlessly.
for (; level >= 5; level--)
{
try {
NdkUtil.GetNdkPlatformLibPath(androidNdkPath, arch, level);
break;
} catch (InvalidOperationException ex) {
// Path not found, continue searching...
continue;
}
}
return(level);
}
//this may be called again if it shows a load error widget
//but once it's loaded the real widgets, it cannot be called again
void Load()
{
//remove and destroy error widgets, if any
var c = this.Child;
if (c != null && c != table1)
{
this.Remove(c);
c.Destroy();
}
filename = project.AndroidManifest;
if (filename.IsNullOrEmpty)
{
var msg = GettextCatalog.GetString("The project has no Android manifest");
AddErrorWidget(CreateAddManifestButton(msg, Stock.Info));
return;
}
if (!File.Exists(filename))
{
var msg = GettextCatalog.GetString("The project's Android manifest is missing");
AddErrorWidget(CreateAddManifestButton(msg, Stock.DialogWarning));
return;
}
try {
manifest = AndroidAppManifest.Load(filename);
} catch (Exception ex) {
var vb = new VBox()
{
Spacing = 6
};
var hb = new HBox()
{
Spacing = 6
};
hb.PackStart(new Image(Stock.DialogError, IconSize.Button), false, false, 0);
var msg = GettextCatalog.GetString("Error reading Android manifest");
hb.PackStart(new Label()
{
Markup = "<big>" + msg + "</big>"
}, false, false, 0);
vb.PackStart(hb, false, false, 0);
var tv = new TextView();
tv.Buffer.InsertAtCursor(ex.ToString());
var sw = new ScrolledWindow();
sw.ShadowType = ShadowType.EtchedIn;
sw.Add(tv);
vb.PackStart(sw, true, true, 0);
AddErrorWidget(vb);
return;
}
if (c != table1)
{
this.Add(table1);
}
InitializeRealWidgets();
packageNameEntry.Text = manifest.PackageName ?? "";
appNameEntry.Text = manifest.ApplicationLabel ?? "";
versionNameEntry.Text = manifest.VersionName ?? "";
versionNumberEntry.Text = manifest.VersionCode ?? "";
appIconCombo.Entry.Text = manifest.ApplicationIcon ?? "";
SetMinSdkVersion(manifest.MinSdkVersion);
SetPermissions(manifest.AndroidPermissions);
SetInstallLocation(manifest.InstallLocation);
loaded = true;
}
protected override void SaveManifest(string manifest)
{
var doc = XDocument.Parse(manifest);
AndroidAppManifest.Load(doc, AndroidVersions).WriteToFile(ManifestOutputPath);
}
protected override string ReadManifest() => AndroidAppManifest.Load(ManifestOutputPath, AndroidVersions) .Document .ToString();
public override string GetBundId()
{
var manifest = AndroidAppManifest.Load(ManifestInputPath, AndroidVersions);
return(manifest.PackageName);
}
/// <summary>
/// NOTE: all file paths used in this method should be full paths. (Or use AsyncTask.WorkingDirectory)
/// </summary>
void GenerateJava(Library library)
{
// In some cases (such as ancient support libraries), R.txt does not exist.
// We can just use the main app's R.txt file and write *all fields* in this case.
bool using_main_r_txt = false;
var r_txt = library.TextFile;
if (!File.Exists(r_txt))
{
LogDebugMessage($"Using main R.txt, R.txt does not exist: {r_txt}");
using_main_r_txt = true;
r_txt = main_r_txt;
}
var manifestFile = library.ManifestFile;
if (!File.Exists(manifestFile))
{
LogDebugMessage($"Skipping, AndroidManifest.xml does not exist: {manifestFile}");
return;
}
var manifest = AndroidAppManifest.Load(manifestFile, MonoAndroidHelper.SupportedVersions);
using (var memory = new MemoryStream())
using (var writer = new StreamWriter(memory, Encoding)) {
// This code is based on the Android gradle plugin
// https://android.googlesource.com/platform/tools/base/+/908b391a9c006af569dfaff08b37f8fdd6c4da89/build-system/builder/src/main/java/com/android/builder/internal/SymbolWriter.java
writer.WriteLine("/* AUTO-GENERATED FILE. DO NOT MODIFY.");
writer.WriteLine(" *");
writer.WriteLine(" * This class was automatically generated by");
writer.WriteLine(" * Xamarin.Android from the resource data it found.");
writer.WriteLine(" * It should not be modified by hand.");
writer.WriteLine(" */");
writer.Write("package ");
writer.Write(manifest.PackageName);
writer.WriteLine(';');
writer.WriteLine();
writer.WriteLine("public final class R {");
using (var reader = File.OpenText(r_txt)) {
string currentClass = null;
foreach (var line in ParseFile(reader))
{
var type = line [Index.Type];
var clazz = line [Index.Class];
var name = line [Index.Name];
if (GetValue(clazz, name, line, using_main_r_txt, out string value))
{
if (clazz != currentClass)
{
// If not the first inner class
if (currentClass != null)
{
writer.WriteLine("\t}");
}
currentClass = clazz;
writer.Write("\tpublic static final class ");
writer.Write(currentClass);
writer.WriteLine(" {");
}
writer.Write("\t\tpublic static final ");
writer.Write(type);
writer.Write(' ');
writer.Write(name);
writer.Write(" = ");
// It may be an int[]
if (value.StartsWith("{", StringComparison.Ordinal))
{
writer.Write("new ");
writer.Write(type);
writer.Write(' ');
}
writer.Write(value);
writer.WriteLine(';');
}
else
{
LogDebugMessage($"{r_txt}: `{type} {clazz} {name}` value not found");
}
}
// If we wrote at least one inner class
if (currentClass != null)
{
writer.WriteLine("\t}");
}
writer.WriteLine('}');
}
writer.Flush();
var r_java = Path.Combine(output_directory, manifest.PackageName.Replace('.', Path.DirectorySeparatorChar), "R.java");
if (MonoAndroidHelper.CopyIfStreamChanged(memory, r_java))
{
LogDebugMessage($"Writing: {r_java}");
}
else
{
LogDebugMessage($"Up to date: {r_java}");
}
}
}