[Xamarin.Android.Build.Tasks] Add Support for CodeBehind for layout files (#1238)

Support generating CodeBehind files for `.axml` layout files. This
removes the need to call `FindViewById<T>()` manually, as properties
generated into the CodeBehind file will call it instead.

The CodeBehind files are generated for all `.axml` files with a build
action of `@(AndroidResource)` *and* contain an XML namespace to
`http://schemas.android.com/tools` and a `tools:class` attribute
that contains the name of the `partial class` to generate:

	<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	    android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"
	    xmlns:tools="http://schemas.xamarin.com/android/tools"
	    tools:class="UnnamedProject.MainActivity"> 
	  <Button
	      android:id="@+id/myButton"
	      android:layout_width="fill_parent"
	      android:layout_height="wrap_content"
	      android:text="@string/hello"
	  />
	</LinearLayout> 

The generated CodeBehind partial class will use the value of the
`//@tools:class` attribute, and will contain a property for each
element with an `//@android:id` attribute. The `//@android:id`
attribute is the name of a generated field, while the containing
element name is the type of the property.

The above XML fragment would partially produce:

	partial class MainActivity {
	  // Call instead of `SetContentView()`
	  private void InitializeContentView ();

	  // Called if `myButton` can't be found
	  partial void OnLayoutViewNotFound<T> (int resourceId, ref T type)
	    where T : global::Android.Views.View;

	  // One property per //@android:id
	  // Throws InvalidOperationException if it can't be found
	  public Button myButton { get; }
	}

This allows replacing the current code pattern of:

	SetContentView (Resource.Layout.NameOfLayoutFilename);
	var button = FindViewById<Button> (Resource.Id.myButton);
	button.Click += delegate {
	};

and instead rely on the CodeBehind properties:

	InitializeContentView ();
	myButton.Click += delegate {
	};

There are two other requirements to make this work:

 1. All declarations of the class specified by the `//@tools:class`
    attribute must be `partial` classes, otherwise a CS0260 error
    will be produced at build time.
 
 2. `InitializeContentView()` must be called instead of
    `SetContentView()`. `InitializeContentView()` itself calls
    `SetContentView()`, providing the `@(AndroidResource)` filename
    as the layout to use.

This feature was originally prototyped by @grendello.

The following is a sample of the kind of code which will be
generated by this new system:

	namespace UnnamedProject {
	  using System;
	  using Android.App;
	  using Android.Widget;
	  using Android.Views;
	  using Android.OS;

	  // Generated from layout file 'Resources/layout/Main.axml'
	  public partial class MainActivity {

	    private Func<Button> @__myButtonFunc;
	    private Button @__myButton;

	    partial void OnLayoutViewNotFound<T> (int resourceId, ref T type)
	      where T : global::Android.Views.View;

	    public Button myButton {
	      get {
	        if (@__myButtonFunc == null) {
	          @__myButtonFunc = this.@__Create_myButton;
	        }
	        return this.@__EnsureView<Button>(this.@__myButtonFunc, ref this.@__myButton);
	      }
	    }

	    private void InitializeContentView() {
	      this.SetContentView(Resource.Layout.Main);
	    }

	    private T @__FindView<T>(global::Android.Views.View parentView, int resourceId)
	      where T : global::Android.Views.View
	    {
	      T view = parentView.FindViewById<T>(resourceId);
	      if ((view == null)) {
	        this.OnLayoutViewNotFound(resourceId, ref view);
	      }
	      if ((view != null)) {
	        return view;
	      }
	      throw new System.InvalidOperationException($"View not found (ID: {resourceId})");
	    }

	    private T @__FindView<T>(global::Android.App.Activity parentView, int resourceId)
	      where T : global::Android.Views.View
	    {
	      T view = parentView.FindViewById<T>(resourceId);
	      if ((view == null)) {
	        this.OnLayoutViewNotFound(resourceId, ref view);
	      }
	      if ((view != null)) {
	        return view;
	      }
	      throw new System.InvalidOperationException($"View not found (ID: {resourceId})");
	    }

	    private T @__FindView<T>(global::Android.App.Fragment parentView, int resourceId)
	      where T : global::Android.Views.View
	    {
	      return this.@__FindView<T>(parentView.Activity, resourceId);
	    }

	    private T @__EnsureView<T>(System.Func<T> creator, ref T field)
	      where T : class
	    {
	      if ((field != null)) {
	        return field;
	      }
	      if ((creator == null)) {
	        throw new System.ArgumentNullException(nameof (creator));
	      }
	      field = creator();
	      return field;
	    }

	    private Button @__Create_myButton() {
	      return this.@__FindView<Button>(this, Resource.Id.myButton);
	    }
	  }
	}

Author: dellis1972

Documentation/LayoutCodeBehind.md

@@ -0,0 +1,98 @@
+---
+id: 11763499-79e9-4868-83e6-41f3061745d1
+title: "Layout CodeBehind"
+dateupdated: 2018-01-29
+---
+
+<a name="Overview" class="injected"></a>
+
+# Overview
+
+Xamarin.Android supports the auto generation of "Code Behind" classes. These classes
+can reduce the amount code a developer writes. You can end up replacing code like
+
+    SetContentView (Resource.Layout.Main);
+    var button = FindViewById<Button> (Resource.Id.myButton);
+        button.Click += delegate {
+    };
+
+with
+
+    InitializeContentView ();
+    myButton.Click += delegate {
+    };
+
+
+<a name="" class="injected"/></a>
+
+# Preparing to use Code Behind
+
+In order to make use of this new feature there are a few changes which are required. 
+An axml/xml file that you want to associate with an activity needs to be modified to 
+include a few extra xml attributes on the root layout element.
+
+    xmlns:tools="http://schemas.xamarin.com/android/tools"
+    tools:class="$(Namespace).$(ClassName)"
+
+The `class` attribute defines the Namespace and ClassName of the code which will be
+generated. For example if you have a layout for your `MainActivity` you would set
+the `tools:class` to `MyAppNamespace.MainActivity`. Note it should be the fully
+qualified name, not just the class name on its own.
+
+The next thing we need to do is to make the `MainActivity` a `partial` class. This
+allows the genereted code to extend the current class which you have written.
+So 
+    public class MainActivity : Activity {
+    }
+
+will become 
+
+    public partial class MainActivity : Activity {
+    }
+
+You then need to make sure you initialize the layout properties by calling
+`InitializeContentView ()` in the `OnCreate()` method of your activity.
+
+    protected override void OnCreate (Bundle bundle)
+    {
+        base.OnCreate (bundle);
+        InitializeContentView ();
+    }
+
+For those of you familiar with System.Windows.Forms this is akin
+to `InitializeComponent`. Once this has been done you can now access
+your layout items via the properties.
+
+    myButton.Click += delegate {
+    };
+
+There is a partial method available which can be implemented to handle
+situations where the View is not found. The method is
+
+    void OnLayoutViewNotFound<T> (int resourceId, ref T type)
+        where T : global::Android.Views.View;
+
+If `FindViewById` returns `null` then the `OnLayoutViewNotFound` method
+will be called (if it is implemented). This is done BEFORE we throw the
+`InvalidOperationException`. This allows the deveoper to handle the 
+situation in a manner which fits the app they are writing. For example
+you might want to switch to a backup view, or just log some additional
+diagnostic information.
+
+# How it works
+
+There are a couple of new MSBuild Tasks which generate the code behind.
+`<CalculateLayoutCodeBehind/>` and `<GenerateCodeBehindForLayout/>`. 
+
+`<CalculateLayoutCodeBehind/>`  scans through the `@(AndroidResources)` of the 
+project looking fo the `tools:class` attributes. Any layout file which does
+not have this on the very first element will be ignored. 
+
+`<GenerateCodeBehindForLayout/>` will then process the discovered files and 
+geneerate the code behind files in  `$(IntermediateOutputDir)generated`. 
+These files are named by combining the name of the layout file along with
+the Namespace and ClassName from the `tools:class` attribute. So if we are
+creating code behind for `MyAppNamespace.MainActivity` for  the `Main.axml`
+you will see an intermediate file named `Main-MyAppNamespace.MainActivity.g.cs`.
+Thes files will automatically be included in the `Compile` MSBuild ItemGroup if it
+exists.

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

@@ -0,0 +1,117 @@
+using System;
+using Microsoft.Build.Utilities;
+using Microsoft.Build.Framework;
+using System.Collections;
+using System.IO;
+using System.Xml;
+using System.Collections.Generic;
+
+namespace Xamarin.Android.Tasks {
+
+	public class CalculateLayoutCodeBehind : Task {
+
+		readonly string LayoutDirSuffix = "layout";
+		readonly string classSuffix = "class";
+		readonly string toolsNamespace = "http://schemas.xamarin.com/android/tools";
+
+		/// <summary>
+		/// Designer Specific Property. Can be used to calcualte the code behind
+		/// file for one specific file. Saves having to process all the resources.
+		/// </summary>
+		/// <value>The specific file.</value>
+		public ITaskItem SpecificFile { get; set; }
+
+		[Required]
+		public ITaskItem [] ResourceFiles { get; set; }
+
+		[Output]
+		public ITaskItem [] CodeBehindFiles { get; set; }
+
+		public override bool Execute ()
+		{
+			Log.LogDebugMessage ("CalculateLayoutCodeBehind Task");
+			Log.LogDebugMessage ("  SpecificFile: {0}", SpecificFile);
+			Log.LogDebugTaskItems ("  ResourceFiles:", ResourceFiles);
+
+			string partialClassNames = null;
+			var codeBehindFiles = new List<ITaskItem> ();
+			if (SpecificFile != null && File.Exists (SpecificFile.ItemSpec)) {
+				string fileName = SpecificFile.ItemSpec;
+				if (IsCodeBehindLayoutFile (fileName, out partialClassNames))
+					CalculateCodeBehindFilenames (fileName, partialClassNames, codeBehindFiles);
+			} else {
+				foreach (var item in ResourceFiles) {
+					string fileName = item.ItemSpec;
+					if (!IsCodeBehindLayoutFile (fileName, out partialClassNames))
+						continue;
+					CalculateCodeBehindFilenames (fileName, partialClassNames, codeBehindFiles);
+				}
+			}
+
+			CodeBehindFiles = codeBehindFiles.ToArray ();
+			if (CodeBehindFiles.Length == 0) {
+				Log.LogDebugMessage ("  No layout file qualifies for code-behind generation");
+			}
+			Log.LogDebugTaskItems ("  CodeBehindFiles:", CodeBehindFiles);
+			return !Log.HasLoggedErrors;
+		}
+
+		void CalculateCodeBehindFilenames (string fileName, string partialClassNames, List<ITaskItem> codeBehindFiles)
+		{
+			string [] classes = partialClassNames?.Split (',');
+			if (classes == null || classes.Length == 0)
+				return;
+
+			foreach (string c in classes) {
+				string cl = c?.Trim ();
+				if (String.IsNullOrEmpty (cl))
+					continue;
+
+				codeBehindFiles.Add(CreateCodeBehindTaskItem (fileName, cl));
+			}
+		}
+
+		ITaskItem CreateCodeBehindTaskItem (string fileName, string partialClassName)
+		{
+			var ret = new TaskItem (fileName);
+			ret.SetMetadata("CodeBehindFileName", $"{Path.GetFileNameWithoutExtension (fileName)}-{partialClassName}.g.cs");
+			ret.SetMetadata("ClassName", partialClassName);
+			return ret;
+		}
+
+		protected bool IsCodeBehindLayoutFile (string fileName, out string partialClassNames)
+		{
+			partialClassNames = null;
+			if (String.IsNullOrEmpty (fileName) || !File.Exists(fileName))
+				return false;
+
+			if (!Path.GetDirectoryName(fileName).EndsWith (LayoutDirSuffix, StringComparison.OrdinalIgnoreCase))
+				return false;
+
+			if (!fileName.EndsWith(".axml", StringComparison.OrdinalIgnoreCase) && !fileName.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
+				return false;
+
+			using (var fs = File.OpenRead (fileName)) {
+				using (var reader = XmlReader.Create (fs)) {
+					while (reader.Read ()) {
+						if (reader.NodeType != XmlNodeType.Element)
+							continue;
+						if (reader.IsStartElement ()) {
+							if (reader.HasAttributes) {
+								partialClassNames = reader.GetAttribute (classSuffix, toolsNamespace);
+								if (!string.IsNullOrEmpty (partialClassNames)) {
+									return true;
+								}
+
+							}
+							// only read the root element. if it doesn't have the data we need
+							// its not an auto layout file.
+							break;
+						}
+					}
+				}
+			}
+			return false;
+		}
+	}
+}