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()
{
// If we don't have a manifest, default to using the assembly name
// If the assembly doesn't have a period in it, duplicate it so it does
PackageName = AndroidAppManifest.CanonicalizePackageName(AssemblyName);
if (string.IsNullOrEmpty(ManifestFile) || !File.Exists(ManifestFile))
{
Log.LogMessage(" PackageName: {0}", PackageName);
return(true);
}
XmlDocument doc = new XmlDocument();
doc.Load(ManifestFile);
if (!doc.DocumentElement.HasAttribute("package"))
{
Log.LogMessage(" PackageName: {0}", PackageName);
return(true);
}
PackageName = AndroidAppManifest.CanonicalizePackageName(doc.DocumentElement.GetAttribute("package"));
Log.LogMessage(" PackageName: {0}", PackageName);
return(true);
}
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);
}
public override bool Execute()
{
if (ProjectFiles.Length != 1)
{
Log.LogError("More than one Android Wear project is specified as the paired project. It can be at most one.");
}
var wearProj = ProjectFiles.First();
var manifestXml = XDocument.Load(wearProj.ItemSpec)
.Root.Elements(msbuildNS + "PropertyGroup").Elements(msbuildNS + "AndroidManifest").Select(e => e.Value).FirstOrDefault();
if (string.IsNullOrEmpty(manifestXml))
{
Log.LogError("Target Wear application's project '{0}' does not specify required 'AndroidManifest' project property.", wearProj);
}
manifestXml = Path.Combine(Path.GetDirectoryName(wearProj.ItemSpec), manifestXml.Replace('\\', Path.DirectorySeparatorChar));
ApplicationManifestFile = manifestXml;
Log.LogDebugMessage(" [Output] ApplicationManifestFile: " + ApplicationManifestFile);
ApplicationPackageName = AndroidAppManifest.CanonicalizePackageName(XDocument.Load(manifestXml).Root.Attributes("package").Select(a => a.Value).FirstOrDefault());
if (string.IsNullOrEmpty(ApplicationPackageName))
{
Log.LogError("Target Wear application's AndroidManifest.xml does not specify required 'package' attribute.");
}
Log.LogDebugMessage(" [Output] ApplicationPackageName: " + ApplicationPackageName);
return(true);
}
public override bool RunTask()
{
if (ProjectFiles.Length != 1)
{
Log.LogCodedError("XA1015", Properties.Resources.XA1015);
}
var wearProj = ProjectFiles.First();
var manifestXml = XDocument.Load(wearProj.ItemSpec)
.Root.Elements(msbuildNS + "PropertyGroup").Elements(msbuildNS + "AndroidManifest").Select(e => e.Value).FirstOrDefault();
if (string.IsNullOrEmpty(manifestXml))
{
Log.LogCodedError("XA1016", Properties.Resources.XA1016, wearProj);
}
manifestXml = Path.Combine(Path.GetDirectoryName(wearProj.ItemSpec), manifestXml.Replace('\\', Path.DirectorySeparatorChar));
ApplicationManifestFile = manifestXml;
Log.LogDebugMessage(" [Output] ApplicationManifestFile: " + ApplicationManifestFile);
ApplicationPackageName = AndroidAppManifest.CanonicalizePackageName(XDocument.Load(manifestXml).Root.Attributes("package").Select(a => a.Value).FirstOrDefault());
if (string.IsNullOrEmpty(ApplicationPackageName))
{
Log.LogCodedError("XA1017", Properties.Resources.XA1017);
}
Log.LogDebugMessage(" [Output] ApplicationPackageName: " + ApplicationPackageName);
return(true);
}
public void SaveTest()
{
if (File.Exists(SaveTestPath))
{
File.Delete(SaveTestPath);
}
var originalManifest = AndroidAppManifest.Create("com.test.test", "Test Label");
originalManifest.MinSdkVersion = 14;
originalManifest.VersionName = "3.3";
originalManifest.VersionCode = 2;
originalManifest.ApplicationIcon = "@drawable/icon";
var cake = Substitute.For <ICakeContext> ();
cake.SerializeAppManifest(SaveTestPath, originalManifest);
var modifiedManifest = cake.DeserializeAppManifest(new FilePath(SaveTestPath));
modifiedManifest.PackageName.Should().Be(originalManifest.PackageName);
modifiedManifest.ApplicationLabel.Should().Be(originalManifest.ApplicationLabel);
modifiedManifest.ApplicationIcon.Should().Be(originalManifest.ApplicationIcon);
modifiedManifest.MinSdkVersion.Should().Be(originalManifest.MinSdkVersion);
modifiedManifest.VersionName.Should().Be("3.3");
modifiedManifest.VersionCode.Should().Be(2);
}
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());
}
public override bool RunTask()
{
if (!string.IsNullOrEmpty(PackageName))
{
PackageName = AndroidAppManifest.CanonicalizePackageName(PackageName);
}
else if (!string.IsNullOrEmpty(ManifestFile) && File.Exists(ManifestFile))
{
using var stream = File.OpenRead(ManifestFile);
using var reader = XmlReader.Create(stream);
if (reader.MoveToContent() == XmlNodeType.Element)
{
var package = reader.GetAttribute("package");
if (!string.IsNullOrEmpty(package))
{
package = ManifestDocument.ReplacePlaceholders(ManifestPlaceholders, package);
PackageName = AndroidAppManifest.CanonicalizePackageName(package);
}
}
}
// If we don't have a manifest, default to using the assembly name
// If the assembly doesn't have a period in it, duplicate it so it does
if (string.IsNullOrEmpty(PackageName))
{
PackageName = AndroidAppManifest.CanonicalizePackageName(AssemblyName);
}
Log.LogDebugMessage($" PackageName: {PackageName}");
return(!Log.HasLoggedErrors);
}
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);
}
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);
}
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 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 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 override bool RunTask()
{
string rawapk = "wearable_app.apk";
string intermediateApkPath = Path.Combine(IntermediateOutputPath, "res", "raw", rawapk);
string intermediateXmlFile = Path.Combine(IntermediateOutputPath, "res", "xml", "wearable_app_desc.xml");
var doc = XDocument.Load(WearAndroidManifestFile);
var wearPackageName = AndroidAppManifest.CanonicalizePackageName(doc.Root.Attribute("package").Value);
var modified = new List <string> ();
if (PackageName != wearPackageName)
{
Log.LogCodedError("XA5211", Properties.Resources.XA5211, wearPackageName, PackageName);
}
if (!File.Exists(WearApplicationApkPath))
{
Log.LogWarning("This application won't contain the paired Wear package because the Wear application package .apk is not created yet. If you are using MSBuild or XBuild, you have to invoke \"SignAndroidPackage\" target.");
return(true);
}
var xml = string.Format(@"<wearableApp package=""{0}"">
<versionCode>{1}</versionCode>
<versionName>{2}</versionName>
<rawPathResId>{3}</rawPathResId>
</wearableApp>
", wearPackageName, doc.Root.Attribute(androidNs + "versionCode").Value, doc.Root.Attribute(androidNs + "versionName").Value, Path.GetFileNameWithoutExtension(rawapk));
if (MonoAndroidHelper.CopyIfChanged(WearApplicationApkPath, intermediateApkPath))
{
Log.LogDebugMessage(" Copied APK to {0}", intermediateApkPath);
modified.Add(intermediateApkPath);
}
Directory.CreateDirectory(Path.GetDirectoryName(intermediateXmlFile));
if (!File.Exists(intermediateXmlFile) || !XDocument.DeepEquals(XDocument.Load(intermediateXmlFile), XDocument.Parse(xml)))
{
File.WriteAllText(intermediateXmlFile, xml);
Log.LogDebugMessage(" Created additional resource as {0}", intermediateXmlFile);
modified.Add(intermediateXmlFile);
}
WearableApplicationDescriptionFile = new TaskItem(intermediateXmlFile);
WearableApplicationDescriptionFile.SetMetadata("_FlatFile", Monodroid.AndroidResource.CalculateAapt2FlatArchiveFileName(intermediateXmlFile));
WearableApplicationDescriptionFile.SetMetadata("_ArchiveDirectory", AndroidLibraryFlatFilesDirectory);
WearableApplicationDescriptionFile.SetMetadata("IsWearApplicationResource", "True");
BundledWearApplicationApkResourceFile = new TaskItem(intermediateApkPath);
BundledWearApplicationApkResourceFile.SetMetadata("_FlatFile", Monodroid.AndroidResource.CalculateAapt2FlatArchiveFileName(intermediateApkPath));
BundledWearApplicationApkResourceFile.SetMetadata("_ArchiveDirectory", AndroidLibraryFlatFilesDirectory);
BundledWearApplicationApkResourceFile.SetMetadata("IsWearApplicationResource", "True");
ModifiedFiles = modified.ToArray();
return(true);
}
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 override bool Execute()
{
Log.LogDebugMessage("PrepareWearApplicationFiles task");
Log.LogDebugTaskItems(" WearAndroidManifestFile:", WearAndroidManifestFile);
Log.LogDebugTaskItems(" IntermediateOutputPath:", IntermediateOutputPath);
Log.LogDebugTaskItems(" WearApplicationApkPath:", WearApplicationApkPath);
string rawapk = "wearable_app.apk";
string intermediateApkPath = Path.Combine(IntermediateOutputPath, "res", "raw", rawapk);
string intermediateXmlFile = Path.Combine(IntermediateOutputPath, "res", "xml", "wearable_app_desc.xml");
var doc = XDocument.Load(WearAndroidManifestFile);
var wearPackageName = AndroidAppManifest.CanonicalizePackageName(doc.Root.Attribute("package").Value);
if (PackageName != wearPackageName)
{
Log.LogCodedError("XA5211", "Embedded wear app package name differs from handheld app package name ({0} != {1}).", wearPackageName, PackageName);
}
if (!File.Exists(WearApplicationApkPath))
{
Log.LogWarning("This application won't contain the paired Wear package because the Wear application package .apk is not created yet. If you are using MSBuild or XBuild, you have to invoke \"SignAndroidPackage\" target.");
return(true);
}
var xml = string.Format(@"<wearableApp package=""{0}"">
<versionCode>{1}</versionCode>
<versionName>{2}</versionName>
<rawPathResId>{3}</rawPathResId>
</wearableApp>
", wearPackageName, doc.Root.Attribute(androidNs + "versionCode").Value, doc.Root.Attribute(androidNs + "versionName").Value, Path.GetFileNameWithoutExtension(rawapk));
MonoAndroidHelper.CopyIfChanged(WearApplicationApkPath, intermediateApkPath);
Directory.CreateDirectory(Path.GetDirectoryName(intermediateXmlFile));
if (!File.Exists(intermediateXmlFile) || !XDocument.DeepEquals(XDocument.Load(intermediateXmlFile), XDocument.Parse(xml)))
{
File.WriteAllText(intermediateXmlFile, xml);
Log.LogDebugMessage(" Created additional resource as {0}", intermediateXmlFile);
}
WearableApplicationDescriptionFile = new TaskItem(intermediateXmlFile);
WearableApplicationDescriptionFile.SetMetadata("IsWearApplicationResource", "True");
BundledWearApplicationApkResourceFile = new TaskItem(intermediateApkPath);
BundledWearApplicationApkResourceFile.SetMetadata("IsWearApplicationResource", "True");
return(true);
}
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 EnsureUsesPermissionElementOrder()
{
var versions = new AndroidVersions(new AndroidVersion [0]);
var manifest = AndroidAppManifest.Create("com.xamarin.test", "Xamarin Test", versions);
manifest.SetAndroidPermissions(new string[] { "FOO" });
var sb = new StringBuilder();
using (var writer = XmlWriter.Create(sb)) {
manifest.Write(writer);
}
var doc = XDocument.Parse(sb.ToString());
var app = doc.Element("manifest").Element("application");
Assert.IsNotNull(app, "Application element should exist");
Assert.IsFalse(app.ElementsAfterSelf().Any(x => x.Name == "uses-permission"));
Assert.IsTrue(app.ElementsBeforeSelf().Any(x => x.Name == "uses-permission"));
}
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 void CanonicalizePackageName()
{
Assert.Throws <ArgumentNullException>(() => AndroidAppManifest.CanonicalizePackageName(null));
Assert.Throws <ArgumentException>(() => AndroidAppManifest.CanonicalizePackageName(""));
Assert.Throws <ArgumentException>(() => AndroidAppManifest.CanonicalizePackageName(" "));
Assert.AreEqual("A.A",
AndroidAppManifest.CanonicalizePackageName("A"));
Assert.AreEqual("Foo.Bar",
AndroidAppManifest.CanonicalizePackageName("Foo.Bar"));
Assert.AreEqual("foo_bar.foo_bar",
AndroidAppManifest.CanonicalizePackageName("foo-bar"));
Assert.AreEqual("x1.x1",
AndroidAppManifest.CanonicalizePackageName("1"));
Assert.AreEqual("x_1.x_2",
AndroidAppManifest.CanonicalizePackageName("_1._2"));
Assert.AreEqual("mfa1.x0.x2_2",
AndroidAppManifest.CanonicalizePackageName("mfa1.0.2_2"));
Assert.AreEqual("My.Cool_Assembly",
AndroidAppManifest.CanonicalizePackageName("My.Cool Assembly"));
Assert.AreEqual("x7Cats.x7Cats",
AndroidAppManifest.CanonicalizePackageName("7Cats"));
}
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;
}
//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);
loaded = true;
}
