[Xamarin.Android.Build.Tasks] <FilterAssemblies/> support missing TFI

Context: https://www.nuget.org/packages/Refractored.Controls.CircleImageView/
Context: https://github.com/Azure-Samples/MyDriving

The MyDriving sample app currently fails to build on master with:

    Resources/layout/fragment_profile.axml(2): error APT0000: attribute civ_border_width (aka com.microsoft.mydriving:civ_border_width) not found.

The failure happens with both `aapt` and `aapt2`.

This layout is using a custom view such as:

    <?xml version="1.0" encoding="utf-8"?>
    <ScrollView
        xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:local="http://schemas.android.com/apk/res-auto">
        ...
        <refractored.controls.CircleImageView local:civ_border_width="0dp" />
        ...
    </ScrollView>

This comes from the `Refractored.Controls.CircleImageView` NuGet
package.

In 5ec3e3a, I added a `<FilterAssemblies/>` MSBuild task that appears
to be to blame. It is not returning
`Refractored.Controls.CircleImageView.dll`, but it needs to!

`Refractored.Controls.CircleImageView.dll` has no `[assembly:
System.Runtime.Versioning.TargetFrameworkAttribute]`...

    // C:\src\des\MyDriving\packages\Refractored.Controls.CircleImageView.1.0.1\lib\MonoAndroid10\Refractored.Controls.CircleImageView.dll
    // Refractored.Controls.CircleImageView, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
    // Global type: <Module>
    // Architecture: x86
    // Runtime: v4.0.30319
    // Hash algorithm: SHA1

    using Android.Runtime;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Security;
    using System.Security.Permissions;

    [assembly: AssemblyTitle("Refractored.Controls.CircleImageView")]
    [assembly: AssemblyDescription("")]
    [assembly: AssemblyConfiguration("")]
    [assembly: AssemblyCompany("")]
    [assembly: AssemblyProduct("")]
    [assembly: AssemblyCopyright("2015 Refractored LLC/James Montemagno")]
    [assembly: AssemblyTrademark("")]
    [assembly: NamespaceMapping(Java = "de.hdodenhof.circleimageview", Managed = "Refractored.Controls")]
    [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
    [assembly: SecurityPermission(8, SkipVerification = true)]
    [assembly: AssemblyVersion("1.0.0.0")]
    [module: UnverifiableCode]

It is indeed a `MonoAndroid` assembly, since it references
`Mono.Android.dll`. It is weird, though...

So I think the fix here is:

* `<FilterAssemblies/>` needs to also check for an assembly reference
  to `Mono.Android` as a fallback.
* `<ResolveAssemblies/>` now adds a `%(MonoAndroidReference)=True`
  item metadata.
* When creating the `@(_ResolvedUserMonoAndroidAssemblies)` item
  group, we also check for `%(MonoAndroidReference)=True`.

I added a test to verify this scenario.

Author: jonathanpeppers

src/Xamarin.Android.Build.Tasks/Tasks/FilterAssemblies.cs

@@ -8,13 +8,18 @@
 namespace Xamarin.Android.Tasks
 {
 	/// <summary>
-	/// Filters a set of assemblies based on a given TargetFrameworkIdentifier
+	/// Filters a set of assemblies based on a given TargetFrameworkIdentifier or References
 	/// </summary>
 	public class FilterAssemblies : Task
 	{
 		[Required]
 		public string TargetFrameworkIdentifier { get; set; }
 
+		/// <summary>
+		/// If TargetFrameworkIdentifier is missing, we can look for Mono.Android.dll references instead
+		/// </summary>
+		public string FallbackReference { get; set; }
+
 		[Required]
 		public bool DesignTimeBuild { get; set; }
 
@@ -40,6 +45,19 @@ public override bool Execute ()
 					var targetFrameworkIdentifier = assemblyDefinition.GetTargetFrameworkIdentifier (reader);
 					if (targetFrameworkIdentifier == TargetFrameworkIdentifier) {
 						output.Add (assemblyItem);
+						continue;
+					}
+					// Fallback to looking at references
+					if (string.IsNullOrEmpty (targetFrameworkIdentifier) && !string.IsNullOrEmpty (FallbackReference)) {
+						Log.LogDebugMessage ($"Checking references for: {assemblyItem.ItemSpec}");
+						foreach (var handle in reader.AssemblyReferences) {
+							var reference = reader.GetAssemblyReference (handle);
+							var name = reader.GetString (reference.Name);
+							if (FallbackReference == name) {
+								output.Add (assemblyItem);
+								break;
+							}
+						}
 					}
 				}
 			}

src/Xamarin.Android.Build.Tasks/Tasks/ResolveAssemblies.cs

@@ -223,22 +223,28 @@ void AddAssemblyReferences (MetadataResolver resolver, Dictionary<string, ITaskI
 			indent += 2;
 
 			// Add this assembly
+			ITaskItem assemblyItem = null;
 			if (topLevel) {
-				if (!string.IsNullOrEmpty (targetFrameworkIdentifier) && assemblies.TryGetValue (assemblyName, out ITaskItem taskItem)) {
-					if (string.IsNullOrEmpty (taskItem.GetMetadata ("TargetFrameworkIdentifier"))) {
-						taskItem.SetMetadata ("TargetFrameworkIdentifier", targetFrameworkIdentifier);
+				if (assemblies.TryGetValue (assemblyName, out assemblyItem)) {
+					if (!string.IsNullOrEmpty (targetFrameworkIdentifier) && string.IsNullOrEmpty (assemblyItem.GetMetadata ("TargetFrameworkIdentifier"))) {
+						assemblyItem.SetMetadata ("TargetFrameworkIdentifier", targetFrameworkIdentifier);
 					}
 				}
 			} else {
-				assemblies [assemblyName] = CreateAssemblyTaskItem (assemblyPath, targetFrameworkIdentifier);
+				assemblies [assemblyName] = 
+					assemblyItem = CreateAssemblyTaskItem (assemblyPath, targetFrameworkIdentifier);
 			}
 
 			// Recurse into each referenced assembly
 			foreach (var handle in reader.AssemblyReferences) {
 				var reference = reader.GetAssemblyReference (handle);
 				string reference_assembly;
 				try {
-					reference_assembly = resolver.Resolve (reader.GetString (reference.Name));
+					var referenceName = reader.GetString (reference.Name);
+					if (assemblyItem != null && referenceName == "Mono.Android") {
+						assemblyItem.SetMetadata ("MonoAndroidReference", "True");
+					}
+					reference_assembly = resolver.Resolve (referenceName);
 				} catch (FileNotFoundException ex) {
 					var references = new StringBuilder ();
 					for (int i = 0; i < resolutionPath.Count; i++) {

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/BuildTest.cs

@@ -3636,6 +3636,36 @@ public void CompilerErrorShouldNotRunLinkAssemblies ()
 				Assert.IsFalse (StringAssertEx.ContainsText (b.LastBuildOutput, "The \"LinkAssemblies\" task failed unexpectedly"), "The LinkAssemblies MSBuild task should not run!");
 			}
 		}
+
+		/// <summary>
+		/// This assembly weirdly has no [assembly: System.Runtime.Versioning.TargetFrameworkAttribute()], at all...
+		/// </summary>
+		[Test]
+		public void AssemblyWithMissingTargetFramework ()
+		{
+			var proj = new XamarinAndroidApplicationProject {
+				AndroidResources = {
+					new AndroidItem.AndroidResource ("Resources\\layout\\test.axml") {
+						TextContent = () => 
+@"<?xml version=""1.0"" encoding=""utf-8""?>
+<ScrollView
+    xmlns:android=""http://schemas.android.com/apk/res/android""
+    xmlns:local=""http://schemas.android.com/apk/res-auto"">
+    <refractored.controls.CircleImageView local:civ_border_width=""0dp"" />
+</ScrollView>"
+					}
+				}
+			};
+			proj.PackageReferences.Add (KnownPackages.CircleImageView);
+			using (var b = CreateApkBuilder (Path.Combine ("temp", TestName))) {
+				Assert.IsTrue (b.Build (proj), "build should have succeeded.");
+
+				// We should have a java stub, in addition to the build succeeding
+				var intermediate = Path.Combine (Root, b.ProjectDirectory, proj.IntermediateOutputPath);
+				var javaStub = Path.Combine (intermediate, "android", "src", "md54908d67eb9afef4acc92753cc61471e9", "CircleImageView.java");
+				FileAssert.Exists (javaStub);
+			}
+		}
 	}
 }
 

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.ProjectTools/Android/KnownPackages.cs

@@ -726,6 +726,16 @@ public static class KnownPackages
 				}
 			},
 		};
+		public static Package CircleImageView = new Package {
+			Id = "Refractored.Controls.CircleImageView",
+			Version = "1.0.1",
+			TargetFramework = "MonoAndroid10",
+			References = {
+				new BuildItem.Reference ("Refractored.Controls.CircleImageView") {
+					MetadataValues = "HintPath=..\\packages\\Refractored.Controls.CircleImageView.1.0.1\\lib\\MonoAndroid10\\Refractored.Controls.CircleImageView.dll"
+				}
+			},
+		};
 	}
 }
 

src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets

@@ -506,6 +506,7 @@ Copyright (C) 2011-2012 Xamarin. All rights reserved.
   <FilterAssemblies
       DesignTimeBuild="$(DesignTimeBuild)"
       TargetFrameworkIdentifier="MonoAndroid"
+      FallbackReference="Mono.Android"
       InputAssemblies="@(_ReferencePath);@(_ReferenceDependencyPaths)">
     <Output TaskParameter="OutputAssemblies" ItemName="_MonoAndroidReferencePath" />
   </FilterAssemblies>
@@ -2213,7 +2214,7 @@ because xbuild doesn't support framework reference assemblies.
 
   <CreateItem
     Include="@(_ResolvedUserAssemblies)"
-    Condition="'%(_ResolvedUserAssemblies.TargetFrameworkIdentifier)' == 'MonoAndroid'">
+    Condition="'%(_ResolvedUserAssemblies.TargetFrameworkIdentifier)' == 'MonoAndroid' Or '%(_ResolvedUserAssemblies.MonoAndroidReference)' == 'True'">
     <Output TaskParameter="Include" ItemName="_ResolvedUserMonoAndroidAssemblies" />
   </CreateItem>
 </Target>