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}"); } } }