├── Sample
    ├── Resources
    │   ├── mipmap-hdpi
    │   │   └── Icon.png
    │   ├── mipmap-mdpi
    │   │   └── Icon.png
    │   ├── mipmap-xhdpi
    │   │   └── Icon.png
    │   ├── mipmap-xxhdpi
    │   │   └── Icon.png
    │   ├── mipmap-xxxhdpi
    │   │   └── Icon.png
    │   ├── values
    │   │   └── Strings.xml
    │   ├── layout
    │   │   ├── Main.axml
    │   │   └── FirstLayout.axml
    │   └── AboutResources.txt
    ├── Properties
    │   ├── AndroidManifest.xml
    │   └── AssemblyInfo.cs
    ├── packages.config
    ├── Assets
    │   └── AboutAssets.txt
    ├── MainActivity.cs
    └── Sample.csproj
├── Xamarin.Android.ActivityController
    ├── Resources
    │   ├── values
    │   │   └── Strings.xml
    │   └── AboutResources.txt
    ├── IActivityResult.cs
    ├── ActivityResults
    │   ├── ContactPickerActivityResult.cs
    │   └── MediaPickerActivityResult.cs
    ├── packages.config
    ├── ActivityResult.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── ActivityControllerExtensions.cs
    ├── ActivityControllerRegistry.cs
    ├── Xamarin.Android.ActivityController.csproj
    ├── ControllerActivity.cs
    └── ActivityController.cs
├── .gitignore
├── LICENSE.md
├── Xamarin.Android.ActivityController.nuspec
├── Xamarin.Android.ActivityController.sln
├── README.md
└── code-behind-x-a.diff


/Sample/Resources/mipmap-hdpi/Icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xamarin/android-activity-controller/HEAD/Sample/Resources/mipmap-hdpi/Icon.png


--------------------------------------------------------------------------------
/Sample/Resources/mipmap-mdpi/Icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xamarin/android-activity-controller/HEAD/Sample/Resources/mipmap-mdpi/Icon.png


--------------------------------------------------------------------------------
/Sample/Resources/mipmap-xhdpi/Icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xamarin/android-activity-controller/HEAD/Sample/Resources/mipmap-xhdpi/Icon.png


--------------------------------------------------------------------------------
/Sample/Resources/mipmap-xxhdpi/Icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xamarin/android-activity-controller/HEAD/Sample/Resources/mipmap-xxhdpi/Icon.png


--------------------------------------------------------------------------------
/Sample/Resources/mipmap-xxxhdpi/Icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xamarin/android-activity-controller/HEAD/Sample/Resources/mipmap-xxxhdpi/Icon.png


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/Resources/values/Strings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 | 	<string name="library_name">Xamarin.Android.ActivityController</string>
4 | </resources>
5 | 


--------------------------------------------------------------------------------
/Sample/Resources/values/Strings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 | 	<string name="hello">Hello World, Click Me!</string>
4 | 	<string name="app_name">XamActivityController</string>
5 | </resources>
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | tools
 2 | bin
 3 | obj
 4 | *.xam
 5 | *.DS_Store
 6 | *.pidb
 7 | *.userprefs
 8 | *.dotSettings
 9 | *.suo
10 | Resource.designer.cs
11 | 
12 | *.a
13 | 
14 | *.xcuserstate
15 | 
16 | *.xcuserstate
17 | 
18 | packages/
19 | externals/
20 | output/
21 | 
22 | 


--------------------------------------------------------------------------------
/Sample/Resources/layout/Main.axml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent">
3 | 	<Button android:id="@+id/myButton" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/hello" />
4 | </LinearLayout>
5 | 


--------------------------------------------------------------------------------
/Sample/Properties/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="com.altusapps.xamactivitycontroller">
3 | 	<uses-sdk android:minSdkVersion="10" />
4 | 	<application android:allowBackup="true" android:icon="@mipmap/icon" android:label="@string/app_name">
5 | 	</application>
6 | </manifest>
7 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/IActivityResult.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Android.Content;
 3 | 
 4 | namespace Android.App
 5 | {
 6 |     public interface IActivityResult
 7 |     {
 8 |         Result ResultCode { get; }
 9 |         int RequestCode { get; }
10 |         Intent Data { get; }
11 |     }
12 | 
13 |     public interface ITypedActivityResult : IActivityResult
14 |     {
15 |         void Parse(Result resultCode, int requestCode, Intent data);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Sample/Resources/layout/FirstLayout.axml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:orientation="vertical"
 4 |     android:layout_width="match_parent"
 5 |     android:layout_height="match_parent">
 6 |     <Button
 7 |         android:id="@+id/myButton"
 8 |         android:layout_width="match_parent"
 9 |         android:layout_height="wrap_content"
10 |         android:text="Pick Contact" />
11 | </LinearLayout>


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ActivityResults/ContactPickerActivityResult.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Android.Content;
 3 | 
 4 | namespace Android.App
 5 | {
 6 |     public class ContactPickerActivityResult : ActivityResult
 7 |     {
 8 |         public ContactPickerActivityResult(Result resultCode, int requestCode, Intent data)
 9 |             : base(resultCode, requestCode, data) { }
10 |         
11 |         public Android.Net.Uri SelectedContactUri { get { return Data?.Data; } }
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/Sample/packages.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <packages>
3 |   <package id="Xamarin.Android.Support.Animated.Vector.Drawable" version="23.3.0" targetFramework="monoandroid70" />
4 |   <package id="Xamarin.Android.Support.v4" version="23.3.0" targetFramework="monoandroid70" />
5 |   <package id="Xamarin.Android.Support.v7.AppCompat" version="23.3.0" targetFramework="monoandroid70" />
6 |   <package id="Xamarin.Android.Support.Vector.Drawable" version="23.3.0" targetFramework="monoandroid70" />
7 | </packages>


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/packages.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <packages>
3 |   <package id="Xamarin.Android.Support.Animated.Vector.Drawable" version="23.3.0" targetFramework="monoandroid70" />
4 |   <package id="Xamarin.Android.Support.v4" version="23.3.0" targetFramework="monoandroid70" />
5 |   <package id="Xamarin.Android.Support.v7.AppCompat" version="23.3.0" targetFramework="monoandroid70" />
6 |   <package id="Xamarin.Android.Support.Vector.Drawable" version="23.3.0" targetFramework="monoandroid70" />
7 | </packages>


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ActivityResult.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Android.Content;
 3 | 
 4 | namespace Android.App
 5 | {
 6 |     public class ActivityResult : IActivityResult
 7 |     {
 8 |         public ActivityResult(Result resultCode, int requestCode, Intent data)
 9 |         {
10 |             ResultCode = resultCode;
11 |             RequestCode = requestCode;
12 |             Data = data;
13 |         }
14 | 
15 |         public Result ResultCode { get; private set; }
16 |         public int RequestCode { get; private set; }
17 |         public Intent Data { get; private set; }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Sample/Assets/AboutAssets.txt:
--------------------------------------------------------------------------------
 1 | Any raw assets you want to be deployed with your application can be placed in
 2 | this directory (and child directories) and given a Build Action of "AndroidAsset".
 3 | 
 4 | These files will be deployed with your package and will be accessible using Android's
 5 | AssetManager, like this:
 6 | 
 7 | public class ReadAsset : Activity
 8 | {
 9 | 	protected override void OnCreate (Bundle bundle)
10 | 	{
11 | 		base.OnCreate (bundle);
12 | 
13 | 		InputStream input = Assets.Open ("my_asset.txt");
14 | 	}
15 | }
16 | 
17 | Additionally, some Android functions will automatically load asset files:
18 | 
19 | Typeface tf = Typeface.CreateFromAsset (Context.Assets, "fonts/samplefont.ttf");
20 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ActivityResults/MediaPickerActivityResult.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using Android.Content;
 4 | 
 5 | namespace Android.App
 6 | {
 7 |     public class MediaPickerActivityResult : ActivityResult
 8 |     {
 9 |         public MediaPickerActivityResult(Result resultCode, int requestCode, Intent data)
10 |             : base(resultCode, requestCode, data) { }
11 | 
12 |         public Android.Net.Uri SelectedMediaUri { get { return Data?.Data; } }
13 | 
14 |         public Stream GetMediaStream(Context context)
15 |         {
16 |             var uri = SelectedMediaUri;
17 |             if (uri == null)
18 |                 return null;
19 |             
20 |             return context.ContentResolver.OpenInputStream(uri);
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | Copyright (c) 2016 Microsoft Corporation
3 | 
4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
5 | 
6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 | 
8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/Sample/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using Android.App;
 4 | 
 5 | // Information about this assembly is defined by the following attributes. 
 6 | // Change them to the values specific to your project.
 7 | 
 8 | [assembly: AssemblyTitle("XamActivityController")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("Xamarin")]
12 | [assembly: AssemblyProduct("")]
13 | [assembly: AssemblyCopyright("Xamarin")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
18 | // The form "{Major}.{Minor}.*" will automatically update the build and revision,
19 | // and "{Major}.{Minor}.{Build}.*" will update just the revision.
20 | 
21 | [assembly: AssemblyVersion("1.0.0")]
22 | 
23 | // The following attributes are used to specify the signing key for the assembly, 
24 | // if desired. See the Mono documentation for more information about signing.
25 | 
26 | //[assembly: AssemblyDelaySign(false)]
27 | //[assembly: AssemblyKeyFile("")]
28 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController.nuspec:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <package>
 3 |   <metadata>
 4 |     <id>Xamarin.Android.ActivityController</id>
 5 |     <title>Xamarin.Android Activity Controller</title>
 6 |     <version>$version$</version>
 7 |     <authors>Xamarin Inc.</authors>
 8 |     <owners>Xamarin Inc.</owners>
 9 |     <summary>Manage your Activities in a more .NET friendly way, including StartActivityForResultAsync</summary>
10 |     <description>
11 |       Manage your Activities in a more .NET friendly way, including StartActivityForResultAsync
12 |     </description>
13 |     <copyright>Copyright © Microsoft Corporation</copyright>
14 |     <projectUrl>https://github.com/xamarin/android-activity-controller</projectUrl>
15 |     <licenseUrl>https://github.com/xamarin/android-activity-controller/blob/master/LICENSE.md</licenseUrl>
16 |     <dependencies>
17 |       <dependency id="Xamarin.Android.Support.v7.AppCompat" version="23.3.0" />
18 |     </dependencies>
19 |   </metadata>
20 |   <files>
21 |     <file src="Xamarin.Android.ActivityController/bin/Release/Xamarin.Android.ActivityController.dll" target="lib/MonoAndroid403" />
22 |   </files>
23 | </package>
24 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | 
 4 | // Information about this assembly is defined by the following attributes. 
 5 | // Change them to the values specific to your project.
 6 | 
 7 | [assembly: AssemblyTitle("Xamarin.Android.ActivityController")]
 8 | [assembly: AssemblyDescription("")]
 9 | [assembly: AssemblyConfiguration("")]
10 | [assembly: AssemblyCompany("Xamarin")]
11 | [assembly: AssemblyProduct("")]
12 | [assembly: AssemblyCopyright("Xamarin")]
13 | [assembly: AssemblyTrademark("")]
14 | [assembly: AssemblyCulture("")]
15 | 
16 | // The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
17 | // The form "{Major}.{Minor}.*" will automatically update the build and revision,
18 | // and "{Major}.{Minor}.{Build}.*" will update just the revision.
19 | 
20 | [assembly: AssemblyVersion("1.0.0")]
21 | 
22 | // The following attributes are used to specify the signing key for the assembly, 
23 | // if desired. See the Mono documentation for more information about signing.
24 | 
25 | //[assembly: AssemblyDelaySign(false)]
26 | //[assembly: AssemblyKeyFile("")]
27 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2012
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xamarin.Android.ActivityController", "Xamarin.Android.ActivityController\Xamarin.Android.ActivityController.csproj", "{520D62E8-76B4-4387-9CF0-C8E1D8D60253}"
 5 | EndProject
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sample", "Sample\Sample.csproj", "{7C81088B-3E56-40C8-AE3A-CEACC83CF4CF}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{520D62E8-76B4-4387-9CF0-C8E1D8D60253}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{520D62E8-76B4-4387-9CF0-C8E1D8D60253}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{520D62E8-76B4-4387-9CF0-C8E1D8D60253}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{520D62E8-76B4-4387-9CF0-C8E1D8D60253}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 		{7C81088B-3E56-40C8-AE3A-CEACC83CF4CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
19 | 		{7C81088B-3E56-40C8-AE3A-CEACC83CF4CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
20 | 		{7C81088B-3E56-40C8-AE3A-CEACC83CF4CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
21 | 		{7C81088B-3E56-40C8-AE3A-CEACC83CF4CF}.Release|Any CPU.Build.0 = Release|Any CPU
22 | 	EndGlobalSection
23 | EndGlobal
24 | 


--------------------------------------------------------------------------------
/Sample/Resources/AboutResources.txt:
--------------------------------------------------------------------------------
 1 | Images, layout descriptions, binary blobs and string dictionaries can be included 
 2 | in your application as resource files.  Various Android APIs are designed to 
 3 | operate on the resource IDs instead of dealing with images, strings or binary blobs 
 4 | directly.
 5 | 
 6 | For example, a sample Android app that contains a user interface layout (main.axml),
 7 | an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) 
 8 | would keep its resources in the "Resources" directory of the application:
 9 | 
10 | Resources/
11 |     drawable/
12 |         icon.png
13 | 
14 |     layout/
15 |         main.axml
16 | 
17 |     values/
18 |         strings.xml
19 | 
20 | In order to get the build system to recognize Android resources, set the build action to
21 | "AndroidResource".  The native Android APIs do not operate directly with filenames, but 
22 | instead operate on resource IDs.  When you compile an Android application that uses resources, 
23 | the build system will package the resources for distribution and generate a class called "R" 
24 | (this is an Android convention) that contains the tokens for each one of the resources 
25 | included. For example, for the above Resources layout, this is what the R class would expose:
26 | 
27 | public class R {
28 |     public class drawable {
29 |         public const int icon = 0x123;
30 |     }
31 | 
32 |     public class layout {
33 |         public const int main = 0x456;
34 |     }
35 | 
36 |     public class strings {
37 |         public const int first_string = 0xabc;
38 |         public const int second_string = 0xbcd;
39 |     }
40 | }
41 | 
42 | You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main 
43 | to reference the layout/main.axml file, or R.strings.first_string to reference the first 
44 | string in the dictionary file values/strings.xml.
45 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/Resources/AboutResources.txt:
--------------------------------------------------------------------------------
 1 | Images, layout descriptions, binary blobs and string dictionaries can be included 
 2 | in your application as resource files.  Various Android APIs are designed to 
 3 | operate on the resource IDs instead of dealing with images, strings or binary blobs 
 4 | directly.
 5 | 
 6 | For example, a sample Android app that contains a user interface layout (main.axml),
 7 | an internationalization string table (strings.xml) and some icons (drawable-XXX/icon.png) 
 8 | would keep its resources in the "Resources" directory of the application:
 9 | 
10 | Resources/
11 |     drawable/
12 |         icon.png
13 | 
14 |     layout/
15 |         main.axml
16 | 
17 |     values/
18 |         strings.xml
19 | 
20 | In order to get the build system to recognize Android resources, set the build action to
21 | "AndroidResource".  The native Android APIs do not operate directly with filenames, but 
22 | instead operate on resource IDs.  When you compile an Android application that uses resources, 
23 | the build system will package the resources for distribution and generate a class called "R" 
24 | (this is an Android convention) that contains the tokens for each one of the resources 
25 | included. For example, for the above Resources layout, this is what the R class would expose:
26 | 
27 | public class R {
28 |     public class drawable {
29 |         public const int icon = 0x123;
30 |     }
31 | 
32 |     public class layout {
33 |         public const int main = 0x456;
34 |     }
35 | 
36 |     public class strings {
37 |         public const int first_string = 0xabc;
38 |         public const int second_string = 0xbcd;
39 |     }
40 | }
41 | 
42 | You would then use R.drawable.icon to reference the drawable/icon.png file, or R.layout.main 
43 | to reference the layout/main.axml file, or R.strings.first_string to reference the first 
44 | string in the dictionary file values/strings.xml.
45 | 


--------------------------------------------------------------------------------
/Sample/MainActivity.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using Android.App;
 3 | using Android.Content;
 4 | using Android.Provider;
 5 | using Android.Support.V7.App;
 6 | using Android.Widget;
 7 | using Xamarin.Android;
 8 | 
 9 | namespace XamActivityController
10 | {
11 |     [Activity(MainLauncher = true, Label = "Activity Controller Test", Theme = "@style/Theme.AppCompat")]
12 |     public class MainActivity : ControllerActivity<MainActivity.MainController>
13 |     {
14 |         public class MainController : ActivityController
15 |         {
16 |             protected override void OnCreate(Android.OS.Bundle savedInstanceState)
17 |             {
18 |                 base.OnCreate(savedInstanceState);
19 | 
20 |                 SetContentView(Resource.Layout.FirstLayout);
21 | 
22 |                 FindViewById<Button>(Resource.Id.myButton).Click += Button_Click;
23 |             }
24 | 
25 |             async void Button_Click(object sender, EventArgs e)
26 |             {
27 |                 // Create the intent
28 |                 var contactPickerIntent = new Intent(Intent.ActionPick, ContactsContract.CommonDataKinds.Phone.ContentUri);
29 | 
30 |                 // Await the started activity for its result
31 |                 var result = await StartActivityForResultAsync(contactPickerIntent);
32 | 
33 |                 // Parse out the selected contact uri
34 |                 var contactUri = result?.Data?.Data;
35 | 
36 |                 // A more simple implementation:
37 |                 //  var result = await PickContactAsync();
38 |                 //  var contactUri = result.SelectedContactUri;
39 | 
40 |                 if (contactUri != null)
41 |                     Toast.MakeText(Activity, "You Picked: " + GetDisplayName(contactUri), ToastLength.Long).Show();
42 |             }
43 | 
44 |             string GetDisplayName(Android.Net.Uri uri)
45 |             {
46 |                 var c = Activity.ContentResolver.Query(uri, null, null, null, null);
47 |                 c.MoveToFirst();
48 |                 return c.GetString(c.GetColumnIndex(ContactsContract.ContactNameColumns.DisplayNamePrimary));
49 |             }
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ActivityControllerExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Threading.Tasks;
 3 | using Android.Content;
 4 | using Android.Provider;
 5 | 
 6 | namespace Android.App
 7 | {
 8 |     public partial class ActivityController
 9 |     {
10 |         public Task<ContactPickerActivityResult> PickContactAsync()
11 |         {
12 |             var contactPickerIntent = new Intent(Intent.ActionPick, ContactsContract.CommonDataKinds.Phone.ContentUri);
13 | 
14 |             return StartActivityForResultAsync<ContactPickerActivityResult>(contactPickerIntent);
15 |         }
16 | 
17 |         public Task<MediaPickerActivityResult> PickPhotoAsync(string title)
18 |         {
19 |             var intent = Intent.CreateChooser (new Intent(Intent.ActionPick).SetType("image/*"), title);
20 | 
21 |             return StartActivityForResultAsync<MediaPickerActivityResult>(intent);
22 |         }
23 | 
24 |         public Task<MediaPickerActivityResult> TakePhotoAsync(string title)
25 |         {
26 |             var intent = Intent.CreateChooser(new Intent(MediaStore.ActionImageCapture).SetType("image/*"), title);
27 | 
28 |             return StartActivityForResultAsync<MediaPickerActivityResult>(intent);
29 |         }
30 | 
31 |         public Task<MediaPickerActivityResult> PickVideoAsync(string title)
32 |         {
33 |             var intent = Intent.CreateChooser(new Intent(Intent.ActionPick).SetType("video/*"), title);
34 | 
35 |             return StartActivityForResultAsync<MediaPickerActivityResult>(intent);
36 |         }
37 | 
38 |         public Task<MediaPickerActivityResult> TakeVideoAsync(string title, int? videoQuality = null, int? videoSizeLimit = null, TimeSpan? videoDurationLimit = null)
39 |         {
40 |             var intent = Intent.CreateChooser(new Intent(MediaStore.ActionImageCapture).SetType("video/*"), title);
41 | 
42 |             if (videoQuality.HasValue)
43 |                 intent.PutExtra(MediaStore.ExtraVideoQuality, videoQuality.Value);
44 |             if (videoSizeLimit.HasValue)
45 |                 intent.PutExtra(MediaStore.ExtraSizeLimit, videoSizeLimit.Value);
46 |             if (videoDurationLimit.HasValue)
47 |                 intent.PutExtra(MediaStore.ExtraDurationLimit, (int)videoDurationLimit.Value.TotalSeconds);
48 |             
49 |             return StartActivityForResultAsync<MediaPickerActivityResult>(intent);
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ActivityControllerRegistry.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Threading.Tasks;
 4 | using Android.App;
 5 | using Android.Content;
 6 | using Android.Support.V7.App;
 7 | 
 8 | namespace Android.App
 9 | {
10 |     internal static class ActivityControllerRegistry
11 |     {
12 |         internal const string ASSOC_ACTIVITY_ID = "ASSOC_ACTIVITY_ID";
13 | 
14 |         static int requestCode = 1001;
15 |         static readonly object requestCodeLockObj = new object();
16 |         internal static int NextRequestCode()
17 |         {
18 |             lock (requestCodeLockObj)
19 |             {
20 |                 var r = requestCode++;
21 |                 if (requestCode >= int.MaxValue)
22 |                     requestCode = 1001;
23 |                 return r;
24 |             }
25 |         }
26 | 
27 |         static readonly Dictionary<string, AssociatedActivityInfo> associatedActivities = new Dictionary<string, AssociatedActivityInfo>();
28 | 
29 |         internal static AssociatedActivityInfo<TController> Associate<TController>(string associatedActivityId, ControllerActivity<TController> activity) where TController : ActivityController
30 |         {
31 |             AssociatedActivityInfo<TController> info;
32 | 
33 |             if (associatedActivities.ContainsKey(associatedActivityId))
34 |             {
35 |                 info = (AssociatedActivityInfo<TController>)Get(associatedActivityId);
36 |             }
37 |             else 
38 |             {
39 |                 info = new AssociatedActivityInfo<TController>
40 |                 {
41 |                     Id = associatedActivityId,
42 |                     ControllerActivity = activity,
43 |                     AppCompatActivity = activity,
44 |                 };
45 |                 associatedActivities.Add(info.Id, info);
46 |             }
47 | 
48 |             if (info.ActivityController == null)
49 |             {
50 |                 info.ActivityController = Activator.CreateInstance<TController>();
51 |                 info.ActivityController.AssociatedActivityId = associatedActivityId;
52 |             }
53 | 
54 |             info.ControllerActivity = activity;
55 |             info.AppCompatActivity = activity;
56 |             info.ActivityController.WireupHandlers(activity);
57 | 
58 |             return info;
59 |         }
60 | 
61 |         internal static void Destroy(string associatedActivityId)
62 |         {
63 |             associatedActivities.Remove(associatedActivityId);
64 |         }
65 | 
66 |         internal static AssociatedActivityInfo<TController> Get<TController>(string associatedActivityId) where TController : ActivityController
67 |         {
68 |             return (AssociatedActivityInfo<TController>)associatedActivities[associatedActivityId];
69 |         }
70 | 
71 |         internal static AssociatedActivityInfo Get(string associatedActivityId)
72 |         {
73 |             return associatedActivities[associatedActivityId];
74 |         }
75 |     }
76 | 
77 |     internal class AssociatedActivityInfo<TController> : AssociatedActivityInfo where TController : ActivityController
78 |     {
79 |         public ControllerActivity<TController> ControllerActivity { get; set; }
80 |         public TController ActivityController { get; set; }
81 |     }
82 | 
83 |     internal class AssociatedActivityInfo
84 |     {
85 |         public string Id { get; set; }
86 |         public AppCompatActivity AppCompatActivity { get; set; }
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Xamarin.Android ActivityController
 2 | ==================================
 3 | 
 4 | 
 5 | The `ActivityController` makes managing Android Activities more .NET friendly.
 6 | 
 7 | [![](https://img.shields.io/jenkins/s/https/jenkins.mono-project.com/Components-AndroidActivityController.svg)](https://jenkins.mono-project.com/view/Components/job/Components-AndroidActivityController/)
 8 | [![](https://img.shields.io/nuget/vpre/Xamarin.Android.ActivityController.svg)](https://www.nuget.org/packages/Xamarin.Android.ActivityController/)
 9 | 
10 | Traditionally, launching subsequent Activities and waiting for them to return their results has been somewhat painful.
11 | With the `ActivityController` you can use `async/await` by starting activities through the `StartActivityForResultAsync (..)` method.  
12 | 
13 | You can use `ActivityController` as a replacement for `AppCompatActivity`.  The underlying lifecycle of your activity is handled for you.
14 | 
15 | Your `ActivityController` subclass can override some of the typical methods you would expect in an `Activity`.  It must be associated with a subclass of `ControllerActivity<TController>`.  Here is a boiler plate implementation:
16 | 
17 | ```csharp
18 | [Activity(MainLauncher = true, Label = "Your Activity", Theme = "@style/Theme.AppCompat")]
19 | public class MainActivity : ControllerActivity<MainActivity.MainController>
20 | {
21 |     public class MainController : ActivityController
22 |     {
23 |         protected override void OnCreate(Android.OS.Bundle savedInstanceState)
24 |         {
25 |             base.OnCreate(savedInstanceState);
26 | 
27 |             SetContentView(Resource.Layout.FirstLayout);
28 | 
29 |             // Your code            
30 |         }
31 |     }
32 | }
33 | ```
34 | 
35 | Now you are ready to call `StartActivityForResultAsync (..)` from your controller:
36 | 
37 | ```csharp
38 | async void Button_Click(object sender, EventArgs e)
39 | {
40 |     var contactPickerIntent = new Intent(Intent.ActionPick, ContactsContract.CommonDataKinds.Phone.ContentUri);
41 | 
42 |     var result = await StartActivityForResultAsync(contactPickerIntent);
43 | 
44 |     var contactUri = result?.Data?.Data;
45 | 
46 | 	// Get Contact Name from the ContentResolver
47 | 	// var displayName = ...
48 | 	
49 |     if (contactUri != null)
50 |         Toast.MakeText(Activity, "You Picked: " + displayName, ToastLength.Long).Show();
51 | }
52 | ```
53 | 
54 | 
55 | You can also access the instance of the underlying `AppCompatActivity` directly via the `Activity` property of your `ActivityController`, as seen in the snippet above.
56 | 
57 | 
58 | Finally, if you need to, you can also alter your subclass of `ControllerActivity` directly to override more methods
59 | and make other changes. 
60 | 
61 | ```csharp
62 | [Activity(Theme = "@style/Theme.AppCompat")]
63 | public class MainActivity : ControllerActivity<MainController>
64 | {
65 |     public override bool OnTouchEvent(Android.Views.MotionEvent e)
66 |     {
67 |         // Do something interesting
68 | 
69 |         return base.OnTouchEvent(e);
70 |     }
71 | }
72 | ```
73 | 
74 | ### Helpers
75 | 
76 | To make some common tasks easier, `ActivityController` also contains some helper methods which construct the appropriate `Intent` and returns a strongly typed version of `ActivityResult` with more useful properties.
77 | 
78 | The helper methods include:
79 | 
80 |  - PickContactAsync
81 | 
82 | ```csharp
83 | var result = await PickContactAsync ();
84 | var contactUri = result.SelectedContactUri;
85 | ```  
86 | 
87 |  - PickPhotoAsync
88 |  - TakePhotoAsync
89 |  - PickVideoAsync
90 |  - TakeVideoAsync
91 | 
92 | ```csharp
93 | var result = await PickPhotoAsync ("Title");
94 | var stream = result.GetMediaStream ();
95 | ```
96 | 
97 | 
98 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/Xamarin.Android.ActivityController.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 6 |     <ProjectGuid>{520D62E8-76B4-4387-9CF0-C8E1D8D60253}</ProjectGuid>
 7 |     <ProjectTypeGuids>{EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 8 |     <OutputType>Library</OutputType>
 9 |     <RootNamespace>Xamarin.Android.ActivityController</RootNamespace>
10 |     <AssemblyName>Xamarin.Android.ActivityController</AssemblyName>
11 |     <TargetFrameworkVersion>v7.0</TargetFrameworkVersion>
12 |     <AndroidResgenFile>Resources\Resource.designer.cs</AndroidResgenFile>
13 |     <AndroidResgenClass>Resource</AndroidResgenClass>
14 |     <MonoAndroidResourcePrefix>Resources</MonoAndroidResourcePrefix>
15 |     <MonoAndroidAssetsPrefix>Assets</MonoAndroidAssetsPrefix>
16 |     <AndroidUseLatestPlatformSdk>true</AndroidUseLatestPlatformSdk>
17 |   </PropertyGroup>
18 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
19 |     <DebugSymbols>true</DebugSymbols>
20 |     <DebugType>full</DebugType>
21 |     <Optimize>false</Optimize>
22 |     <OutputPath>bin\Debug</OutputPath>
23 |     <DefineConstants>DEBUG;</DefineConstants>
24 |     <ErrorReport>prompt</ErrorReport>
25 |     <WarningLevel>4</WarningLevel>
26 |     <AndroidLinkMode>None</AndroidLinkMode>
27 |     <AndroidSupportedAbis>arm64-v8a;armeabi;armeabi-v7a;x86</AndroidSupportedAbis>
28 |   </PropertyGroup>
29 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
30 |     <DebugSymbols>true</DebugSymbols>
31 |     <DebugType>pdbonly</DebugType>
32 |     <Optimize>true</Optimize>
33 |     <OutputPath>bin\Release</OutputPath>
34 |     <ErrorReport>prompt</ErrorReport>
35 |     <WarningLevel>4</WarningLevel>
36 |     <AndroidManagedSymbols>true</AndroidManagedSymbols>
37 |     <AndroidUseSharedRuntime>false</AndroidUseSharedRuntime>
38 |   </PropertyGroup>
39 |   <ItemGroup>
40 |     <Reference Include="System" />
41 |     <Reference Include="System.Xml" />
42 |     <Reference Include="System.Core" />
43 |     <Reference Include="Mono.Android" />
44 |     <Reference Include="Xamarin.Android.Support.v4">
45 |       <HintPath>..\packages\Xamarin.Android.Support.v4.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.v4.dll</HintPath>
46 |     </Reference>
47 |     <Reference Include="Xamarin.Android.Support.Vector.Drawable">
48 |       <HintPath>..\packages\Xamarin.Android.Support.Vector.Drawable.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.Vector.Drawable.dll</HintPath>
49 |     </Reference>
50 |     <Reference Include="Xamarin.Android.Support.Animated.Vector.Drawable">
51 |       <HintPath>..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.Animated.Vector.Drawable.dll</HintPath>
52 |     </Reference>
53 |     <Reference Include="Xamarin.Android.Support.v7.AppCompat">
54 |       <HintPath>..\packages\Xamarin.Android.Support.v7.AppCompat.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.v7.AppCompat.dll</HintPath>
55 |     </Reference>
56 |   </ItemGroup>
57 |   <ItemGroup>
58 |     <Compile Include="Resources\Resource.designer.cs" />
59 |     <Compile Include="Properties\AssemblyInfo.cs" />
60 |     <Compile Include="ActivityController.cs" />
61 |     <Compile Include="ControllerActivity.cs" />
62 |     <Compile Include="ActivityControllerRegistry.cs" />
63 |     <Compile Include="IActivityResult.cs" />
64 |     <Compile Include="ActivityResults\ContactPickerActivityResult.cs" />
65 |     <Compile Include="ActivityResult.cs" />
66 |     <Compile Include="ActivityControllerExtensions.cs" />
67 |     <Compile Include="ActivityResults\MediaPickerActivityResult.cs" />
68 |   </ItemGroup>
69 |   <ItemGroup>
70 |     <None Include="Resources\AboutResources.txt" />
71 |     <None Include="packages.config" />
72 |   </ItemGroup>
73 |   <ItemGroup>
74 |     <AndroidResource Include="Resources\values\Strings.xml" />
75 |   </ItemGroup>
76 |   <ItemGroup>
77 |     <Folder Include="ActivityResults\" />
78 |   </ItemGroup>
79 |   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
80 |   <Import Project="..\packages\Xamarin.Android.Support.Vector.Drawable.23.3.0\build\Xamarin.Android.Support.Vector.Drawable.targets" Condition="Exists('..\packages\Xamarin.Android.Support.Vector.Drawable.23.3.0\build\Xamarin.Android.Support.Vector.Drawable.targets')" />
81 | </Project>


--------------------------------------------------------------------------------
/Sample/Sample.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 5 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 6 |     <ProjectGuid>{7C81088B-3E56-40C8-AE3A-CEACC83CF4CF}</ProjectGuid>
 7 |     <ProjectTypeGuids>{EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
 8 |     <OutputType>Library</OutputType>
 9 |     <RootNamespace>XamActivityController</RootNamespace>
10 |     <AssemblyName>XamActivityController</AssemblyName>
11 |     <TargetFrameworkVersion>v7.0</TargetFrameworkVersion>
12 |     <AndroidApplication>True</AndroidApplication>
13 |     <AndroidResgenFile>Resources\Resource.designer.cs</AndroidResgenFile>
14 |     <AndroidResgenClass>Resource</AndroidResgenClass>
15 |     <AndroidManifest>Properties\AndroidManifest.xml</AndroidManifest>
16 |     <MonoAndroidResourcePrefix>Resources</MonoAndroidResourcePrefix>
17 |     <MonoAndroidAssetsPrefix>Assets</MonoAndroidAssetsPrefix>
18 |     <AndroidUseLatestPlatformSdk>true</AndroidUseLatestPlatformSdk>
19 |   </PropertyGroup>
20 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
21 |     <DebugSymbols>true</DebugSymbols>
22 |     <DebugType>full</DebugType>
23 |     <Optimize>false</Optimize>
24 |     <OutputPath>bin\Debug</OutputPath>
25 |     <DefineConstants>DEBUG;</DefineConstants>
26 |     <ErrorReport>prompt</ErrorReport>
27 |     <WarningLevel>4</WarningLevel>
28 |     <AndroidLinkMode>None</AndroidLinkMode>
29 |   </PropertyGroup>
30 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
31 |     <DebugSymbols>true</DebugSymbols>
32 |     <DebugType>pdbonly</DebugType>
33 |     <Optimize>true</Optimize>
34 |     <OutputPath>bin\Release</OutputPath>
35 |     <ErrorReport>prompt</ErrorReport>
36 |     <WarningLevel>4</WarningLevel>
37 |     <AndroidManagedSymbols>true</AndroidManagedSymbols>
38 |     <AndroidUseSharedRuntime>false</AndroidUseSharedRuntime>
39 |   </PropertyGroup>
40 |   <ItemGroup>
41 |     <Reference Include="System" />
42 |     <Reference Include="System.Xml" />
43 |     <Reference Include="System.Core" />
44 |     <Reference Include="Mono.Android" />
45 |     <Reference Include="Xamarin.Android.Support.v4">
46 |       <HintPath>..\packages\Xamarin.Android.Support.v4.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.v4.dll</HintPath>
47 |     </Reference>
48 |     <Reference Include="Xamarin.Android.Support.Vector.Drawable">
49 |       <HintPath>..\packages\Xamarin.Android.Support.Vector.Drawable.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.Vector.Drawable.dll</HintPath>
50 |     </Reference>
51 |     <Reference Include="Xamarin.Android.Support.Animated.Vector.Drawable">
52 |       <HintPath>..\packages\Xamarin.Android.Support.Animated.Vector.Drawable.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.Animated.Vector.Drawable.dll</HintPath>
53 |     </Reference>
54 |     <Reference Include="Xamarin.Android.Support.v7.AppCompat">
55 |       <HintPath>..\packages\Xamarin.Android.Support.v7.AppCompat.23.3.0\lib\MonoAndroid403\Xamarin.Android.Support.v7.AppCompat.dll</HintPath>
56 |     </Reference>
57 |   </ItemGroup>
58 |   <ItemGroup>
59 |     <Compile Include="Resources\Resource.designer.cs" />
60 |     <Compile Include="Properties\AssemblyInfo.cs" />
61 |     <Compile Include="MainActivity.cs" />
62 |   </ItemGroup>
63 |   <ItemGroup>
64 |     <None Include="Resources\AboutResources.txt" />
65 |     <None Include="Properties\AndroidManifest.xml" />
66 |     <None Include="Assets\AboutAssets.txt" />
67 |     <None Include="packages.config" />
68 |   </ItemGroup>
69 |   <ItemGroup>
70 |     <AndroidResource Include="Resources\layout\Main.axml" />
71 |     <AndroidResource Include="Resources\values\Strings.xml" />
72 |     <AndroidResource Include="Resources\mipmap-hdpi\Icon.png" />
73 |     <AndroidResource Include="Resources\mipmap-mdpi\Icon.png" />
74 |     <AndroidResource Include="Resources\mipmap-xhdpi\Icon.png" />
75 |     <AndroidResource Include="Resources\mipmap-xxhdpi\Icon.png" />
76 |     <AndroidResource Include="Resources\mipmap-xxxhdpi\Icon.png" />
77 |     <AndroidResource Include="Resources\layout\FirstLayout.axml" />
78 |   </ItemGroup>
79 |   <ItemGroup>
80 |     <Folder Include="Resources\drawable\" />
81 |   </ItemGroup>
82 |   <ItemGroup>
83 |     <ProjectReference Include="..\Xamarin.Android.ActivityController\Xamarin.Android.ActivityController.csproj">
84 |       <Project>{520D62E8-76B4-4387-9CF0-C8E1D8D60253}</Project>
85 |       <Name>Xamarin.Android.ActivityController</Name>
86 |     </ProjectReference>
87 |   </ItemGroup>
88 |   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
89 |   <Import Project="packages\Xamarin.Android.Support.Vector.Drawable.23.3.0\build\Xamarin.Android.Support.Vector.Drawable.targets" Condition="Exists('packages\Xamarin.Android.Support.Vector.Drawable.23.3.0\build\Xamarin.Android.Support.Vector.Drawable.targets')" />
90 | </Project>


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ControllerActivity.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Threading.Tasks;
  3 | using Android.App;
  4 | using Android.Content;
  5 | using Android.OS;
  6 | using Android.Support.V7.App;
  7 | using Android.Widget;
  8 | 
  9 | namespace Android.App
 10 | {
 11 |     public abstract class ControllerActivity<TController> : AppCompatActivity where TController : ActivityController
 12 |     {
 13 |         public TController GetController ()
 14 |         {
 15 |             var info = (AssociatedActivityInfo<TController>)ActivityControllerRegistry.Get(AssociatedActivityId);
 16 |             return info.ActivityController;
 17 |         }
 18 | 
 19 |         public string AssociatedActivityId { get; private set; }
 20 | 
 21 |         public Task<ActivityResult> StartActivityForResultAsync(Intent intent)
 22 |         {
 23 |             return StartActivityForResultAsync(intent, ActivityControllerRegistry.NextRequestCode());
 24 |         }
 25 | 
 26 |         public Task<ActivityResult> StartActivityForResultAsync(Intent intent, int requestCode)
 27 |         {
 28 |             var info = (AssociatedActivityInfo<TController>)ActivityControllerRegistry.Get(AssociatedActivityId);
 29 |             return info.ControllerActivity.StartActivityForResultAsync(intent, requestCode);
 30 |         }
 31 | 
 32 |         internal Action<Bundle> OnCreateHandler { get; set; }
 33 |         protected override void OnCreate(Bundle savedInstanceState)
 34 |         {
 35 |             AssociatedActivityId = savedInstanceState?.GetString(ActivityControllerRegistry.ASSOC_ACTIVITY_ID)
 36 |                                          ?? Intent?.GetStringExtra(ActivityControllerRegistry.ASSOC_ACTIVITY_ID)
 37 |                                          ?? Guid.NewGuid().ToString();
 38 | 
 39 |             ActivityControllerRegistry.Associate<TController> (AssociatedActivityId, this);
 40 | 
 41 |             base.OnCreate(savedInstanceState);
 42 | 
 43 |             OnCreateHandler?.Invoke(savedInstanceState);
 44 |         }
 45 | 
 46 |         internal Action<int, Result, Intent> OnActivityResultHandler { get; set; }
 47 |         protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
 48 |         {
 49 |             base.OnActivityResult(requestCode, resultCode, data);
 50 | 
 51 |             OnActivityResultHandler?.Invoke(requestCode, resultCode, data);
 52 |         }
 53 | 
 54 |         internal Action<Bundle> OnSaveInstanceStateHandler { get; set; }
 55 |         protected override void OnSaveInstanceState(Bundle outState)
 56 |         {
 57 |             outState.PutString(ActivityControllerRegistry.ASSOC_ACTIVITY_ID, AssociatedActivityId);
 58 | 
 59 |             OnSaveInstanceStateHandler?.Invoke(outState);
 60 | 
 61 |             base.OnSaveInstanceState(outState);
 62 |         }
 63 | 
 64 |         internal Action<Bundle> OnRestoreInstanceStateHandler { get; set; }
 65 |         protected override void OnRestoreInstanceState(Bundle savedInstanceState)
 66 |         {
 67 |             OnRestoreInstanceStateHandler?.Invoke(savedInstanceState);
 68 |             base.OnRestoreInstanceState(savedInstanceState);
 69 |         }
 70 | 
 71 |         internal Action OnDestroyHandler { get; set; }
 72 |         protected override void OnDestroy()
 73 |         {
 74 |             OnDestroyHandler?.Invoke();
 75 |             base.OnDestroy();
 76 |         }
 77 | 
 78 |         internal Action OnStartHandler { get; set; }
 79 |         protected override void OnStart()
 80 |         {
 81 |             base.OnStart();
 82 |             OnStartHandler?.Invoke();
 83 |         }
 84 | 
 85 |         internal Action OnStopHandler { get; set; }
 86 |         protected override void OnStop()
 87 |         {
 88 |             OnStopHandler?.Invoke();
 89 |             base.OnStop();
 90 |         }
 91 | 
 92 |         internal Action OnPauseHandler { get; set; }
 93 |         protected override void OnPause()
 94 |         {
 95 |             OnPauseHandler?.Invoke();
 96 |             base.OnPause();
 97 |         }
 98 | 
 99 |         internal Action OnResumeHandler { get; set; }
100 |         protected override void OnResume()
101 |         {
102 |             base.OnResume();
103 |             OnResumeHandler?.Invoke();
104 |         }
105 | 
106 |         internal Action OnBackPressedHandler { get; set; }
107 |         public override void OnBackPressed()
108 |         {
109 |             base.OnBackPressed();
110 |             OnBackPressedHandler?.Invoke();
111 |         }
112 | 
113 |         internal Action OnRestartHandler { get; set; }
114 |         protected override void OnRestart()
115 |         {
116 |             base.OnRestart();
117 |             OnRestartHandler?.Invoke();
118 |         }
119 | 
120 |         internal Action OnLowMemoryHandler { get; set; }
121 |         public override void OnLowMemory()
122 |         {
123 |             base.OnLowMemory();
124 |             OnLowMemoryHandler?.Invoke();
125 |         }
126 | 
127 |         internal Action OnPostResumeHandler { get; set; }
128 |         protected override void OnPostResume()
129 |         {
130 |             base.OnPostResume();
131 |             OnPostResumeHandler?.Invoke();
132 |         }
133 | 
134 |         internal Action OnAttachedToWindowHandler { get; set; }
135 |         public override void OnAttachedToWindow()
136 |         {
137 |             base.OnAttachedToWindow();
138 |             OnAttachedToWindowHandler?.Invoke();
139 |         }
140 | 
141 |         internal Action OnDetachedFromWindowHandler { get; set; }
142 |         public override void OnDetachedFromWindow()
143 |         {
144 |             base.OnDetachedFromWindow();
145 |             OnDetachedFromWindowHandler?.Invoke();
146 |         }
147 | 
148 |         internal Action<int,string[],Content.PM.Permission[]> OnRequestPermissionsResultHandler { get; set; }
149 |         public override void OnRequestPermissionsResult(int requestCode, string[] permissions, Content.PM.Permission[] grantResults)
150 |         {
151 |             base.OnRequestPermissionsResult(requestCode, permissions, grantResults);
152 |             OnRequestPermissionsResultHandler?.Invoke(requestCode, permissions, grantResults);
153 |         }
154 | 
155 |         internal Action<Views.IContextMenu,Views.View,Views.IContextMenuContextMenuInfo> OnCreateContextMenuHandler { get; set; }
156 |         public override void OnCreateContextMenu(Views.IContextMenu menu, Views.View v, Views.IContextMenuContextMenuInfo menuInfo)
157 |         {
158 |             base.OnCreateContextMenu(menu, v, menuInfo);
159 |             OnCreateContextMenuHandler?.Invoke(menu, v, menuInfo);
160 |         }
161 | 
162 |         internal Action<Intent> OnNewIntentHandler { get; set; }
163 |         protected override void OnNewIntent(Intent intent)
164 |         {
165 |             base.OnNewIntent(intent);
166 |             OnNewIntentHandler?.Invoke(intent);
167 |         }
168 |     }
169 | }
170 | 


--------------------------------------------------------------------------------
/Xamarin.Android.ActivityController/ActivityController.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Threading.Tasks;
  4 | using Android.App;
  5 | using Android.Content;
  6 | using Android.OS;
  7 | using Android.Provider;
  8 | using Android.Support.V7.App;
  9 | using Android.Widget;
 10 | 
 11 | namespace Android.App
 12 | {
 13 |     public partial class ActivityController
 14 |     {
 15 |         public string AssociatedActivityId { get; internal set; } = Guid.NewGuid().ToString();
 16 | 
 17 |         public TController GetActivity<TActivity, TController>() where TActivity : ActivityController where TController : ControllerActivity<TActivity>
 18 |         {
 19 |             var info = ActivityControllerRegistry.Get<TActivity>(AssociatedActivityId);
 20 | 
 21 |             return (TController)info.ControllerActivity;
 22 |         }
 23 | 
 24 |         public AppCompatActivity Activity
 25 |         {
 26 |             get
 27 |             {
 28 |                 return ActivityControllerRegistry.Get(AssociatedActivityId).AppCompatActivity;
 29 |             }
 30 |         }
 31 | 
 32 |         // Stores pending startActivityForResult invocations
 33 |         Dictionary<int, TaskCompletionSource<ActivityResult>> activityCompletionSources = new Dictionary<int, TaskCompletionSource<ActivityResult>> ();
 34 | 
 35 |         public Task<ActivityResult> StartActivityForResultAsync(Intent intent)
 36 |         {
 37 |             return StartActivityForResultAsync(intent, ActivityControllerRegistry.NextRequestCode());
 38 |         }
 39 | 
 40 |         public Task<ActivityResult> StartActivityForResultAsync(Intent intent, int requestCode)
 41 |         {
 42 |             if (activityCompletionSources.ContainsKey(requestCode))
 43 |                 throw new ArgumentException("There is already an activity request started for this requestCode", nameof(requestCode));
 44 | 
 45 |             var tcs = new TaskCompletionSource<ActivityResult>();
 46 | 
 47 |             activityCompletionSources.Add(requestCode, tcs);
 48 | 
 49 |             Activity.StartActivityForResult(intent, requestCode);
 50 | 
 51 |             return tcs.Task;
 52 |         }
 53 | 
 54 |         public Task<TActivityResult> StartActivityForResultAsync<TActivityResult>(Intent intent) where TActivityResult : ActivityResult
 55 |         {
 56 |             return StartActivityForResultAsync<TActivityResult>(intent, ActivityControllerRegistry.NextRequestCode());
 57 |         }
 58 | 
 59 |         public async Task<TActivityResult> StartActivityForResultAsync<TActivityResult>(Intent intent, int requestCode) where TActivityResult : ActivityResult
 60 |         {
 61 |             var result = await StartActivityForResultAsync(intent, requestCode);
 62 | 
 63 |             if (result == null)
 64 |                 return null;
 65 |             
 66 |             return (TActivityResult)Activator.CreateInstance(typeof(TActivityResult), result.ResultCode, result.RequestCode, result.Data);
 67 |         }
 68 | 
 69 |         internal void WireupHandlers<TActivityController>(ControllerActivity<TActivityController> activity) where TActivityController : ActivityController
 70 |         {
 71 |             activity.OnStartHandler = OnStart;
 72 |             activity.OnCreateHandler = (p) => this.OnCreate (p);
 73 |             activity.OnActivityResultHandler = HandleOnActivityResult;
 74 |             activity.OnStopHandler = OnStop;
 75 |             activity.OnResumeHandler = OnResume;
 76 |             activity.OnPauseHandler = OnPause;
 77 |             activity.OnDestroyHandler = OnDestroy;
 78 |             activity.OnRestoreInstanceStateHandler = OnRestoreInstanceState;
 79 |             activity.OnSaveInstanceStateHandler = OnSaveInstanceState;
 80 |             activity.OnDestroyHandler = OnDestroy;
 81 |             activity.OnBackPressedHandler = OnBackPressed;
 82 |             activity.OnRestartHandler = OnRestart;
 83 |             activity.OnLowMemoryHandler = OnLowMemory;
 84 |             activity.OnPostResumeHandler = OnPostResume;
 85 |             activity.OnAttachedToWindowHandler = OnAttachedToWindow;
 86 |             activity.OnDetachedFromWindowHandler = OnDetachedFromWindow;
 87 |             activity.OnRequestPermissionsResultHandler = OnRequestPermissionsResult;
 88 |             activity.OnCreateContextMenuHandler = OnCreateContextMenu;
 89 |             activity.OnNewIntentHandler = OnNewIntent;
 90 |         }
 91 | 
 92 |         void HandleOnActivityResult(int requestCode, Result resultCode, Intent data)
 93 |         {
 94 |             if (activityCompletionSources.ContainsKey(requestCode))
 95 |             {
 96 |                 var tcs = activityCompletionSources[requestCode];
 97 | 
 98 |                 if (resultCode == Result.Canceled)
 99 |                 {
100 |                     tcs.TrySetResult(null);
101 |                     return;
102 |                 }
103 | 
104 |                 tcs.TrySetResult(new ActivityResult(resultCode, requestCode, data));
105 |             }
106 |             else {
107 |                 OnActivityResult(requestCode, resultCode, data);
108 |             }
109 |         }
110 | 
111 |         protected virtual void OnActivityResult(int requestCode, Result resultCode, Intent data)
112 |         {
113 |         }
114 | 
115 |         protected virtual void OnStart()
116 |         {
117 |         }
118 | 
119 |         protected virtual void OnCreate(Bundle savedInstanceState)
120 |         {
121 |         }
122 | 
123 |         protected virtual void Finish()
124 |         {
125 |             Activity.Finish();
126 |             ActivityControllerRegistry.Destroy(AssociatedActivityId);
127 |         }
128 | 
129 |         public TView FindViewById<TView>(int resourceId) where TView : global::Android.Views.View
130 |         {
131 |             return Activity.FindViewById<TView>(resourceId);
132 |         }
133 | 
134 |         public void SetContentView(int layoutResId)
135 |         {
136 |             Activity.SetContentView(layoutResId);
137 |         }
138 | 
139 |         protected virtual void OnSaveInstanceState(Bundle outState)
140 |         {
141 |         }
142 | 
143 |         protected virtual void OnRestoreInstanceState(Bundle savedInstanceState)
144 |         {
145 |         }
146 | 
147 |         protected virtual void OnDestroy()
148 |         {
149 |         }
150 | 
151 |         protected virtual void OnStop()
152 |         {
153 |         }
154 | 
155 |         protected virtual void OnPause()
156 |         {
157 |         }
158 | 
159 |         protected virtual void OnResume()
160 |         {
161 |         }
162 | 
163 |         protected virtual void OnBackPressed()
164 |         {
165 |         }
166 | 
167 |         protected virtual void OnRestart()
168 |         {
169 |         }
170 | 
171 |         public virtual void OnLowMemory()
172 |         {
173 |         }
174 | 
175 |         protected virtual void OnPostResume()
176 |         {
177 |         }
178 | 
179 |         public virtual void OnAttachedToWindow()
180 |         {
181 |         }
182 | 
183 |         public virtual void OnDetachedFromWindow()
184 |         {
185 |         }
186 | 
187 |         public virtual void OnRequestPermissionsResult(int requestCode, string[] permissions, Content.PM.Permission[] grantResults)
188 |         {
189 |         }
190 | 
191 |         public virtual void OnCreateContextMenu(Views.IContextMenu menu, Views.View v, Views.IContextMenuContextMenuInfo menuInfo)
192 |         {
193 |         }
194 | 
195 |         protected virtual void OnNewIntent(Intent intent)
196 |         {
197 |         }
198 |     }
199 | }
200 | 


--------------------------------------------------------------------------------
/code-behind-x-a.diff:
--------------------------------------------------------------------------------
   1 | diff --git a/Xamarin.Android.sln b/Xamarin.Android.sln
   2 | index af6dd5e..b0fb40c 100644
   3 | --- a/Xamarin.Android.sln
   4 | +++ b/Xamarin.Android.sln
   5 | @@ -101,6 +101,8 @@ Global
   6 |  		Release|AnyCPU = Release|AnyCPU
   7 |  		XAIntegrationDebug|AnyCPU = XAIntegrationDebug|AnyCPU
   8 |  		XAIntegrationRelease|AnyCPU = XAIntegrationRelease|AnyCPU
   9 | +		XAIntegrationDebug|Any CPU = XAIntegrationDebug|Any CPU
  10 | +		XAIntegrationRelease|Any CPU = XAIntegrationRelease|Any CPU
  11 |  	EndGlobalSection
  12 |  	GlobalSection(ProjectConfigurationPlatforms) = postSolution
  13 |  		{3F1F2F50-AF1A-4A5A-BEDB-193372F068D7}.Debug|AnyCPU.ActiveCfg = Debug|Any CPU
  14 | @@ -488,5 +490,8 @@ Global
  15 |  		$0.DotNetNamingPolicy = $1
  16 |  		$1.DirectoryNamespaceAssociation = None
  17 |  		$1.ResourceNamePolicy = FileFormatDefault
  18 | +		$0.StandardHeader = $2
  19 | +		$2.Text = @\n${FileName}\n \nAuthor:\n      ${AuthorName} <${AuthorEmail}>\n\nCopyright (c) ${Year} ${CopyrightHolder}\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the "Software"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.
  20 | +		$2.IncludeInNewFiles = True
  21 |  	EndGlobalSection
  22 |  EndGlobal
  23 | diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/FindLayoutsWithCodeBehind.cs b/src/Xamarin.Android.Build.Tasks/Tasks/FindLayoutsWithCodeBehind.cs
  24 | new file mode 100644
  25 | index 0000000..2cc6a30
  26 | --- /dev/null
  27 | +++ b/src/Xamarin.Android.Build.Tasks/Tasks/FindLayoutsWithCodeBehind.cs
  28 | @@ -0,0 +1,132 @@
  29 | +//
  30 | +// GenerateLayoutsCodeBehind.cs
  31 | +//
  32 | +// Author:
  33 | +//       Marek Habersack <grendel@twistedcode.net>
  34 | +//
  35 | +// Copyright (c) 2016 Microsoft Corp. (http://microsoft.com/)
  36 | +//
  37 | +// Permission is hereby granted, free of charge, to any person obtaining a copy
  38 | +// of this software and associated documentation files (the "Software"), to deal
  39 | +// in the Software without restriction, including without limitation the rights
  40 | +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  41 | +// copies of the Software, and to permit persons to whom the Software is
  42 | +// furnished to do so, subject to the following conditions:
  43 | +//
  44 | +// The above copyright notice and this permission notice shall be included in
  45 | +// all copies or substantial portions of the Software.
  46 | +//
  47 | +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  48 | +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  49 | +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  50 | +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  51 | +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  52 | +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  53 | +// THE SOFTWARE.
  54 | +
  55 | +using System;
  56 | +using System.Collections.Generic;
  57 | +using System.IO;
  58 | +using System.Linq;
  59 | +using System.Xml.Linq;
  60 | +using System.Xml.XPath;
  61 | +
  62 | +using Microsoft.Build.Utilities;
  63 | +using Microsoft.Build.Framework;
  64 | +
  65 | +namespace Xamarin.Android.Tasks
  66 | +{
  67 | +	public class FindLayoutsWithCodeBehind : Task
  68 | +	{
  69 | +		static readonly string LayoutDirSuffix = Path.DirectorySeparatorChar + "layout";
  70 | +
  71 | +		[Required]
  72 | +		public ITaskItem[] ResourceFiles { get; set; }
  73 | +
  74 | +		// Meant to be used by the IDE when it wants to (re)generate code-behind for a single, specific file
  75 | +		// Specifying it explicitly saves us time
  76 | +		public string ExplicitFile { get; set; }
  77 | +
  78 | +		[Output]
  79 | +		public ITaskItem[] LayoutFiles { get; set; }
  80 | +
  81 | +		public override bool Execute ()
  82 | +		{
  83 | +			Log.LogDebugMessage   ("FindLayoutsWithCodeBehind Task");
  84 | +			Log.LogDebugTaskItems ("  ResourceFiles:", ResourceFiles);
  85 | +			Log.LogDebugMessage   ("  ExplicitFile: {0}", ExplicitFile);
  86 | +
  87 | +			if (ResourceFiles.Length == 0)
  88 | +				return true;
  89 | +
  90 | +			string klass;
  91 | +			var layoutFiles = new List<ITaskItem> ();
  92 | +			if (!String.IsNullOrEmpty (ExplicitFile)) {
  93 | +				if (IsCodeBehindLayoutFile (ExplicitFile, out klass))
  94 | +					CreateLayoutItems (ExplicitFile, klass, layoutFiles);
  95 | +			} else {
  96 | +				foreach (ITaskItem item in ResourceFiles) {
  97 | +					string fileName = item.ItemSpec;
  98 | +					if (!IsCodeBehindLayoutFile (fileName, out klass))
  99 | +						continue;
 100 | +					CreateLayoutItems (fileName, klass, layoutFiles);
 101 | +				}
 102 | +			}
 103 | +
 104 | +			if (layoutFiles.Count == 0) {
 105 | +				Log.LogDebugMessage ("  No layout file qualifies for code-behind generation");
 106 | +				return true;
 107 | +			}
 108 | +			LayoutFiles = layoutFiles.ToArray ();
 109 | +
 110 | +			Log.LogDebugTaskItems ("  LayoutFiles:", LayoutFiles);
 111 | +			return !Log.HasLoggedErrors;
 112 | +		}
 113 | +
 114 | +		void CreateLayoutItems (string fileName, string klass, List <ITaskItem> layoutFiles)
 115 | +		{
 116 | +			string[] classes = klass?.Split (',');
 117 | +			if (classes == null || classes.Length == 0)
 118 | +				return;
 119 | +
 120 | +			foreach (string c in classes) {
 121 | +				string cl = c?.Trim ();
 122 | +				if (String.IsNullOrEmpty (cl))
 123 | +					continue;
 124 | +
 125 | +				layoutFiles.Add (CreateLayoutItem (fileName, cl));
 126 | +			}
 127 | +		}
 128 | +
 129 | +		ITaskItem CreateLayoutItem (string fileName, string klass)
 130 | +		{
 131 | +			var ret = new TaskItem (fileName);
 132 | +			ret.SetMetadata ("CodeBehindFileName", $"{Path.GetFileNameWithoutExtension (fileName)}-{klass}.cs");
 133 | +			ret.SetMetadata ("ClassName", klass);
 134 | +			return ret;
 135 | +		}
 136 | +
 137 | +		protected bool IsCodeBehindLayoutFile (string fileName, out string klass)
 138 | +		{
 139 | +			klass = null;
 140 | +			if (String.IsNullOrEmpty (fileName) || !File.Exists (fileName))
 141 | +				return false;
 142 | +
 143 | +			if (!Path.GetDirectoryName (fileName).EndsWith (LayoutDirSuffix, StringComparison.OrdinalIgnoreCase))
 144 | +				return false;
 145 | +
 146 | +			if (!fileName.EndsWith (".axml", StringComparison.OrdinalIgnoreCase) && !fileName.EndsWith (".xml", StringComparison.OrdinalIgnoreCase))
 147 | +				return false;
 148 | +
 149 | +			var doc = XDocument.Load (fileName);
 150 | +			XAttribute tools = doc.Root?.Attributes ()?.FirstOrDefault (xa => xa.IsNamespaceDeclaration && xa.Name.LocalName == "tools");
 151 | +			if (tools == null)
 152 | +				return false;
 153 | +
 154 | +			XNamespace toolsNS = tools.Value;
 155 | +			XAttribute classAttribute = doc.Root?.Attribute (toolsNS + "class");
 156 | +			klass = classAttribute?.Value;
 157 | +			return !String.IsNullOrEmpty (klass);
 158 | +		}
 159 | +	}
 160 | +}
 161 | diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateLayoutsCodeBehind.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateLayoutsCodeBehind.cs
 162 | new file mode 100644
 163 | index 0000000..c4b8f48
 164 | --- /dev/null
 165 | +++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateLayoutsCodeBehind.cs
 166 | @@ -0,0 +1,823 @@
 167 | +//
 168 | +// GenerateLayoutsCodeBehind.cs
 169 | +//
 170 | +// Author:
 171 | +//       Marek Habersack <grendel@twistedcode.net>
 172 | +//
 173 | +// Copyright (c) 2016 Microsoft Corp. (http://microsoft.com/)
 174 | +//
 175 | +// Permission is hereby granted, free of charge, to any person obtaining a copy
 176 | +// of this software and associated documentation files (the "Software"), to deal
 177 | +// in the Software without restriction, including without limitation the rights
 178 | +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 179 | +// copies of the Software, and to permit persons to whom the Software is
 180 | +// furnished to do so, subject to the following conditions:
 181 | +//
 182 | +// The above copyright notice and this permission notice shall be included in
 183 | +// all copies or substantial portions of the Software.
 184 | +//
 185 | +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 186 | +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 187 | +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 188 | +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 189 | +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 190 | +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 191 | +// THE SOFTWARE.
 192 | +
 193 | +using System;
 194 | +using System.CodeDom;
 195 | +using System.CodeDom.Compiler;
 196 | +using System.Collections.Generic;
 197 | +using System.IO;
 198 | +using System.Linq;
 199 | +using System.Reflection;
 200 | +using System.Runtime.CompilerServices;
 201 | +using System.Text;
 202 | +using System.Xml;
 203 | +using System.Xml.Linq;
 204 | +using System.Xml.XPath;
 205 | +
 206 | +using Microsoft.Build.Utilities;
 207 | +using Microsoft.Build.Framework;
 208 | +using Microsoft.CSharp;
 209 | +
 210 | +namespace Xamarin.Android.Tasks
 211 | +{
 212 | +	public class GenerateLayoutsCodeBehind : Task
 213 | +	{
 214 | +		const string UserDataIsMainKey = "IsMain";
 215 | +		const string ChildClassParentFieldName = "__parent";
 216 | +
 217 | +		sealed class Widget
 218 | +		{
 219 | +			Lazy <List <Widget>> children = new Lazy <List <Widget>> (false);
 220 | +			Lazy <HashSet <string>> idCache = new Lazy <HashSet <string>> (false);
 221 | +
 222 | +			public List <Widget> Children {
 223 | +				get { return children.Value; }
 224 | +			}
 225 | +
 226 | +			public HashSet <string> IDCache {
 227 | +				get { return idCache.Value; }
 228 | +			}
 229 | +
 230 | +			public bool IsLeaf {
 231 | +				get { return !children.IsValueCreated || children.Value.Count == 0; }
 232 | +			}
 233 | +
 234 | +			public string Name { get; set; }
 235 | +			public string Type { get; set; }
 236 | +			public string ID { get; set; }
 237 | +			public string FileName { get; set; }
 238 | +			public int Line { get; set; }
 239 | +			public int Column { get; set; }
 240 | +			public Widget Parent { get; set; }
 241 | +			public bool IsInaccessible { get; set; }
 242 | +			public bool IsRoot { get; set; }
 243 | +
 244 | +			public void AddChild (Widget child)
 245 | +			{
 246 | +				if (child == null)
 247 | +					return;
 248 | +				if (String.IsNullOrEmpty (child.ID))
 249 | +					throw new InvalidOperationException ("Attempt to add a child without ID");
 250 | +
 251 | +				Children.Add (child);
 252 | +				if (IDCache.Contains (child.ID))
 253 | +					child.IsInaccessible = true;
 254 | +				else
 255 | +					IDCache.Add (child.ID);
 256 | +			}
 257 | +		}
 258 | +
 259 | +		enum MethodAccessibility {
 260 | +			Internal,
 261 | +			Private,
 262 | +			Protected,
 263 | +			Public,
 264 | +		};
 265 | +
 266 | +		[Flags]
 267 | +		enum MethodScope {
 268 | +			Abstract = 0x01,
 269 | +			Override = 0x02,
 270 | +			Static   = 0x04,
 271 | +			Virtual  = 0x08,
 272 | +			Final    = 0x10,
 273 | +		}
 274 | +
 275 | +		static readonly List <string> StandardImports = new List <string> {
 276 | +			"System",
 277 | +			"Android.App",
 278 | +			"Android.Widget",
 279 | +			"Android.Views",
 280 | +			"Android.OS"
 281 | +		};
 282 | +
 283 | +		[Required]
 284 | +		public ITaskItem[] LayoutFiles { get; set; }
 285 | +
 286 | +		[Required]
 287 | +		public ITaskItem[] CodeBehindFiles { get; set; }
 288 | +
 289 | +		public override bool Execute ()
 290 | +		{
 291 | +			Log.LogDebugMessage   ("GenerateResourceCodeBehind Task");
 292 | +			Log.LogDebugTaskItems ("  LayoutFiles:", LayoutFiles);
 293 | +			Log.LogDebugTaskItems ("  CodeBehindFiles:", CodeBehindFiles);
 294 | +
 295 | +			if (LayoutFiles.Length == 0)
 296 | +				return true;
 297 | +
 298 | +			if (LayoutFiles.Length != CodeBehindFiles.Length) {
 299 | +				Log.LogError ("There must be the same number of items in both 'LayoutFiles' and 'CodeBehindFiles'");
 300 | +				return false;
 301 | +			}
 302 | +
 303 | +			var generatorOptions = new CodeGeneratorOptions {
 304 | +				BlankLinesBetweenMembers = true,
 305 | +				VerbatimOrder = false,
 306 | +			};
 307 | +			var generatedFiles = new List<ITaskItem> ();
 308 | +			for (int i = 0; i < LayoutFiles.Length; i++) {
 309 | +				ITaskItem item = GenerateCode (LayoutFiles [i], CodeBehindFiles [i], generatorOptions);
 310 | +				if (item != null)
 311 | +					generatedFiles.Add (item);
 312 | +			}
 313 | +
 314 | +			Log.LogDebugTaskItems ("  GeneratedFiles:", generatedFiles.ToArray ());
 315 | +			return !Log.HasLoggedErrors;
 316 | +		}
 317 | +
 318 | +		XNamespace GetNamespace (XElement e, string name)
 319 | +		{
 320 | +			return e?.Attributes ()?.FirstOrDefault (xa => xa.IsNamespaceDeclaration && xa.Name.LocalName == name)?.Value;
 321 | +		}
 322 | +
 323 | +		XAttribute GetAttribute (XElement e, XNamespace ns, string name)
 324 | +		{
 325 | +			return e?.Attribute (ns + name);
 326 | +		}
 327 | +
 328 | +		void GetLineInfo (XElement e, out int line, out int column)
 329 | +		{
 330 | +			var linfo = e as IXmlLineInfo;
 331 | +			if (!linfo.HasLineInfo ()) {
 332 | +				line = column = -1;
 333 | +				return;
 334 | +			}
 335 | +			line = linfo.LineNumber;
 336 | +			column = linfo.LinePosition;
 337 | +		}
 338 | +
 339 | +		bool GenerateLayoutMembers (CodeTypeDeclaration mainClass, string fileName)
 340 | +		{
 341 | +			var doc = XDocument.Load (fileName, LoadOptions.SetLineInfo);
 342 | +			XNamespace toolsNS = GetNamespace (doc.Root, "tools");
 343 | +			if (toolsNS == null) {
 344 | +				Log.LogError ($"Layout file '{fileName}' doesn't define the 'tools' namespace");
 345 | +				return false;
 346 | +			}
 347 | +
 348 | +			XAttribute classAttribute = GetAttribute (doc.Root, toolsNS, "class");
 349 | +			string klass = classAttribute?.Value?.Trim ();
 350 | +			if (String.IsNullOrEmpty (klass)) {
 351 | +				Log.LogError ($"Layout file '{fileName}' doesn't have root element with the 'tools:class' attribute or the attribute has invalid value");
 352 | +				return false;
 353 | +			}
 354 | +
 355 | +			XNamespace androidNS = GetNamespace (doc.Root, "android");
 356 | +			var globalIdCache = new Dictionary <string, int> (StringComparer.Ordinal);
 357 | +			var root = new Widget {
 358 | +				IsRoot = true
 359 | +			};
 360 | +			LoadWidgets (fileName, doc.Root, androidNS, root, globalIdCache);
 361 | +			return GenerateWidgetMembers (mainClass, mainClass.Name, root, globalIdCache, String.Empty);
 362 | +		}
 363 | +
 364 | +		bool GenerateWidgetMembers (CodeTypeDeclaration klass, string parentType, Widget widget, Dictionary <string, int> globalIdCache, string indent)
 365 | +		{
 366 | +			Log.LogDebugMessage ($"Widget members for class {klass.Name}");
 367 | +			if (!widget.IsRoot)
 368 | +				Log.LogDebugMessage ($"{indent}Widget {widget.Name} with ID '{widget.ID}' and type '{widget.Type}'");
 369 | +
 370 | +			if (widget.IsInaccessible)
 371 | +				return true;
 372 | +
 373 | +			if (widget.IsLeaf)
 374 | +				return GenerateLeafWidgetMember (klass, widget, globalIdCache);
 375 | +
 376 | +			CodeTypeDeclaration widgetClass;
 377 | +			if (widget.IsRoot)
 378 | +				widgetClass = klass;
 379 | +			else {
 380 | +				if (!GenerateGroupWidgetMember (klass, parentType, widget, globalIdCache, out widgetClass))
 381 | +					return false;
 382 | +			}
 383 | +
 384 | +			bool ret = true;
 385 | +			foreach (Widget child in widget.Children) {
 386 | +				// Don't fail when one widget fails, try to generate as many members as possible thus
 387 | +				// making it possible for the developer to know what all is broken at a glance instead
 388 | +				// of re-running the build
 389 | +				if (!GenerateWidgetMembers (widgetClass, parentType, child, globalIdCache, indent + "   "))
 390 | +					ret = false;
 391 | +			}
 392 | +
 393 | +			return ret;
 394 | +		}
 395 | +
 396 | +		bool CreateWidgetMembers (CodeTypeDeclaration klass, Widget widget, string memberType, Dictionary <string, int> globalIdCache, CodeMemberMethod creator)
 397 | +		{
 398 | +			bool ret = true;
 399 | +			CodeMemberField backingField = CreateBackingField (widget, memberType);
 400 | +
 401 | +			klass.Members.Add (backingField);
 402 | +			klass.Members.Add (creator);
 403 | +			klass.Members.Add (CreateProperty (widget, memberType, backingField, creator, GetParent (klass)));
 404 | +
 405 | +			return ret;
 406 | +		}
 407 | +
 408 | +		CodeExpression GetParent (CodeTypeDeclaration klass)
 409 | +		{
 410 | +			if (klass.UserData.Contains (UserDataIsMainKey) && (bool)klass.UserData [UserDataIsMainKey])
 411 | +				return new CodeThisReferenceExpression ();
 412 | +			return new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), ChildClassParentFieldName);
 413 | +		}
 414 | +
 415 | +		bool GenerateLeafWidgetMember (CodeTypeDeclaration klass, Widget widget, Dictionary <string, int> globalIdCache)
 416 | +		{
 417 | +			List <Widget> findPath = GetShortestFindPath (widget, globalIdCache);
 418 | +			return CreateWidgetMembers (klass, widget, widget.Type, globalIdCache, ImplementWidgetCreator (widget, GetParent (klass), findPath));
 419 | +		}
 420 | +
 421 | +		bool GenerateGroupWidgetMember (CodeTypeDeclaration klass, string parentType, Widget widget, Dictionary <string, int> globalIdCache, out CodeTypeDeclaration widgetClass)
 422 | +		{
 423 | +			string className = GetClassName (widget);
 424 | +			widgetClass = AddLayoutClass (klass, GetClassName (widget), parentType);
 425 | +			return CreateWidgetMembers (klass, widget, className, globalIdCache, ImplementLayoutClassCreator (widget));
 426 | +		}
 427 | +
 428 | +		List <Widget> GetShortestFindPath (Widget widget, Dictionary <string, int> globalIdCache)
 429 | +		{
 430 | +			if (HasUniqueId (widget, globalIdCache)) {
 431 | +				return new List <Widget> {
 432 | +					widget
 433 | +				};
 434 | +			}
 435 | +
 436 | +			var ret = new List <Widget> ();
 437 | +			var w = widget.Parent;
 438 | +			while (w != null && !w.IsRoot) {
 439 | +				ret.Add (w);
 440 | +				if (HasUniqueId (w, globalIdCache))
 441 | +					break;
 442 | +				w = w.Parent;
 443 | +			}
 444 | +			ret.Add (widget);
 445 | +
 446 | +			return ret;
 447 | +		}
 448 | +
 449 | +		CodeMemberProperty CreateProperty (Widget widget, string returnType, CodeMemberField backingField, CodeMemberMethod creator, CodeExpression parent)
 450 | +		{
 451 | +			var ensureViewRef = new CodeMethodReferenceExpression (parent, "__EnsureView");
 452 | +			ensureViewRef.TypeArguments.Add (new CodeTypeReference (returnType));
 453 | +
 454 | +			var ensureViewInvoke = new CodeMethodInvokeExpression (
 455 | +				ensureViewRef,
 456 | +				new CodeExpression[] { new CodeMethodReferenceExpression (new CodeThisReferenceExpression (), creator.Name),
 457 | +						       new CodeDirectionExpression (FieldDirection.Ref, new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), backingField.Name))
 458 | +				}
 459 | +			);
 460 | +
 461 | +			var ret = new CodeMemberProperty {
 462 | +				Name = widget.Name,
 463 | +				HasGet = true,
 464 | +				HasSet = false,
 465 | +				Type = new CodeTypeReference (returnType),
 466 | +				LinePragma = new CodeLinePragma (widget.FileName, widget.Line),
 467 | +				Attributes = MemberAttributes.Public | MemberAttributes.Final
 468 | +			};
 469 | +
 470 | +			ret.GetStatements.Add (new CodeMethodReturnStatement (ensureViewInvoke));
 471 | +			return ret;
 472 | +		}
 473 | +
 474 | +		string GetClassName (Widget widget)
 475 | +		{
 476 | +			return $"__{widget.Name}_Views";
 477 | +		}
 478 | +
 479 | +		CodeMemberMethod ImplementLayoutClassCreator (Widget widget)
 480 | +		{
 481 | +			string className = GetClassName (widget);
 482 | +			CodeMemberMethod method = CreateMethod ($"__CreateClass_{className}", MethodAccessibility.Private, MethodScope.Final, className);
 483 | +
 484 | +			var instantiate = new CodeObjectCreateExpression (
 485 | +				className,
 486 | +				new[] { new CodeThisReferenceExpression () }
 487 | +			);
 488 | +			method.Statements.Add (new CodeMethodReturnStatement (instantiate));
 489 | +
 490 | +			return method;
 491 | +		}
 492 | +
 493 | +		CodeMemberMethod ImplementWidgetCreator (Widget widget, CodeExpression parent, List <Widget> findPath)
 494 | +		{
 495 | +			CodeMemberMethod method = CreateMethod ($"__Create_{widget.Name}", MethodAccessibility.Private, MethodScope.Final, widget.Type);
 496 | +
 497 | +			if (findPath.Count == 1) {
 498 | +				method.Statements.Add (new CodeMethodReturnStatement (CreateFindViewInvoke (findPath [0], parent, parent)));
 499 | +				return method;
 500 | +			}
 501 | +			var viewVar = new CodeVariableDeclarationStatement ("View", "view");
 502 | +			var viewVarRef = new CodeVariableReferenceExpression ("view");
 503 | +			method.Statements.Add (viewVar);
 504 | +
 505 | +			CodeExpression parentView = parent;
 506 | +			foreach (Widget w in findPath) {
 507 | +				CodeMethodInvokeExpression findViewCall = CreateFindViewInvoke (w, parent, parentView);
 508 | +				var assignView = new CodeAssignStatement (viewVarRef, findViewCall);
 509 | +				var ifViewNull = new CodeConditionStatement (
 510 | +					new CodeBinaryOperatorExpression (viewVarRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
 511 | +					new[] { new CodeMethodReturnStatement (new CodePrimitiveExpression (null)) }
 512 | +				);
 513 | +
 514 | +				method.Statements.Add (assignView);
 515 | +				method.Statements.Add (ifViewNull);
 516 | +
 517 | +				if (parentView == parent)
 518 | +					parentView = viewVarRef;
 519 | +			}
 520 | +
 521 | +			method.Statements.Add (new CodeMethodReturnStatement (new CodeCastExpression (widget.Type, viewVarRef)));
 522 | +
 523 | +			return method;
 524 | +		}
 525 | +
 526 | +		CodeMethodInvokeExpression CreateFindViewInvoke (Widget widget, CodeExpression parent, CodeExpression parentView)
 527 | +		{
 528 | +			var findViewRef = new CodeMethodReferenceExpression (parent, "__FindView");
 529 | +			findViewRef.TypeArguments.Add (new CodeTypeReference (widget.Type));
 530 | +
 531 | +			return new CodeMethodInvokeExpression (findViewRef, new CodeExpression[] { parentView, new CodeSnippetExpression (widget.ID) });
 532 | +		}
 533 | +
 534 | +		CodeMemberField CreateBackingField (Widget widget, string memberType)
 535 | +		{
 536 | +			return new CodeMemberField (memberType, $"__{widget.Name}") {
 537 | +				LinePragma = new CodeLinePragma (widget.FileName, widget.Line)
 538 | +			};
 539 | +		}
 540 | +
 541 | +		bool HasUniqueId (Widget widget, Dictionary <string, int> globalIdCache)
 542 | +		{
 543 | +			int count;
 544 | +			return (!globalIdCache.TryGetValue (widget.ID, out count) || count == 1);
 545 | +		}
 546 | +
 547 | +		void LoadWidgets (string fileName, XElement xmlRoot, XNamespace androidNS, Widget widgetRoot, Dictionary <string, int> globalIdCache)
 548 | +		{
 549 | +			if (!xmlRoot.HasElements)
 550 | +				return;
 551 | +
 552 | +			foreach (XElement child in xmlRoot.Elements ()) {
 553 | +				XAttribute id = GetAttribute (child, androidNS, "id");
 554 | +				Widget root = null;
 555 | +				if (id != null) {
 556 | +					root = CreateWidget (fileName, child, id.Value, widgetRoot);
 557 | +					if (root != null)
 558 | +						Log.LogDebugMessage ($"Adding Widget '{root.Name}' with ID '{root.ID}'");
 559 | +					widgetRoot.AddChild (root);
 560 | +					if (!String.IsNullOrEmpty (root?.ID)) {
 561 | +						if (globalIdCache.ContainsKey (root.ID))
 562 | +							globalIdCache [root.ID]++;
 563 | +						else
 564 | +							globalIdCache.Add (root.ID, 1);
 565 | +					}
 566 | +				}
 567 | +				LoadWidgets (fileName, child, androidNS, root ?? widgetRoot, globalIdCache);
 568 | +			}
 569 | +		}
 570 | +
 571 | +		void ParseID (string id, out string parsedId, out string name)
 572 | +		{
 573 | +			parsedId = null;
 574 | +			name = null;
 575 | +			id = id?.Trim ();
 576 | +			if (String.IsNullOrEmpty (id))
 577 | +				return;
 578 | +
 579 | +			string ns;
 580 | +			bool capitalize = false;
 581 | +			if (id.StartsWith ("@id/", StringComparison.Ordinal) || id.StartsWith ("@+id/", StringComparison.Ordinal))
 582 | +				ns = "Resource.Id";
 583 | +			else if (id.StartsWith ("@android:id/")) {
 584 | +				ns = "Android.Resource.Id";
 585 | +				capitalize = true;
 586 | +			} else
 587 | +				throw new InvalidOperationException ($"Unknown Android ID format '{id}'");
 588 | +
 589 | +			var sb = new StringBuilder (id.Substring (id.IndexOf ('/') + 1));
 590 | +			if (capitalize)
 591 | +				sb [0] = Char.ToUpper (sb [0]);
 592 | +
 593 | +			name = sb.ToString ();
 594 | +			parsedId = $"{ns}.{name}";
 595 | +		}
 596 | +
 597 | +		Widget CreateWidget (string fileName, XElement e, string id, Widget parent)
 598 | +		{
 599 | +			int line, column;
 600 | +			GetLineInfo (e, out line, out column);
 601 | +
 602 | +			if (String.IsNullOrEmpty (id)) {
 603 | +				Log.LogWarning ($"Element {e.Name} defined at '{fileName}:({line},{column})' has an empty ID");
 604 | +				return null;
 605 | +			}
 606 | +
 607 | +			string parsedId, name;
 608 | +			ParseID (id, out parsedId, out name);
 609 | +			var ret = new Widget {
 610 | +				Name = name,
 611 | +				Type = e.Name.LocalName,
 612 | +				ID = parsedId,
 613 | +				Parent = parent,
 614 | +				FileName = fileName,
 615 | +				Line = line,
 616 | +				Column = column
 617 | +			};
 618 | +
 619 | +			return ret;
 620 | +		}
 621 | +
 622 | +		ITaskItem GenerateCode (ITaskItem layoutFile, ITaskItem codeBehindFile, CodeGeneratorOptions generatorOptions)
 623 | +		{
 624 | +			ITaskItem ret = null;
 625 | +
 626 | +			string klass = layoutFile.GetMetadata ("ClassName");
 627 | +			if (String.IsNullOrEmpty (klass)) {
 628 | +				Log.LogError ($"Layout file {layoutFile.ItemSpec} doesn't specify the code-behind class name.");
 629 | +				return null;
 630 | +			}
 631 | +			int idx = klass.LastIndexOf ('.');
 632 | +			string className;
 633 | +			string namespaceName;
 634 | +
 635 | +			if (idx >= 0) {
 636 | +				className = klass.Substring (idx + 1);
 637 | +				namespaceName = klass.Substring (0, idx);
 638 | +			} else {
 639 | +				className = klass;
 640 | +				namespaceName = null;
 641 | +			}
 642 | +
 643 | +			if (String.IsNullOrEmpty (className)) {
 644 | +				Log.LogError ($"Layout file {layoutFile.ItemSpec} doesn't specify a valid code-behind class name");
 645 | +				return null;
 646 | +			}
 647 | +
 648 | +			var compileUnit = new CodeCompileUnit ();
 649 | +			var ns = new CodeNamespace (namespaceName);
 650 | +			compileUnit.Namespaces.Add (ns);
 651 | +			foreach (string import in StandardImports)
 652 | +				ns.Imports.Add (new CodeNamespaceImport (import));
 653 | +
 654 | +			CodeTypeDeclaration mainClass = AddMainClass (layoutFile, ns, className);
 655 | +			if (!GenerateLayoutMembers (mainClass, Path.GetFullPath (layoutFile.ItemSpec)))
 656 | +				Log.LogError ($"Layout code-behind failed for '{layoutFile.ItemSpec}'");
 657 | +			else {
 658 | +				var provider = new CSharpCodeProvider ();
 659 | +				using (var sw = new StreamWriter (codeBehindFile.ItemSpec, false, Encoding.UTF8)) {
 660 | +					using (var tw = new IndentedTextWriter (sw, "\t")) {
 661 | +						provider.GenerateCodeFromCompileUnit (compileUnit, tw, generatorOptions);
 662 | +					}
 663 | +				}
 664 | +			}
 665 | +
 666 | +			return new TaskItem (codeBehindFile.ItemSpec);;
 667 | +		}
 668 | +
 669 | +		CodeTypeDeclaration CreateClass (string className, bool isPartial = false, bool isPublic = true, bool isNested = false, bool isSealed = false)
 670 | +		{
 671 | +			var ret = new CodeTypeDeclaration (className) {
 672 | +				IsClass = true,
 673 | +				IsPartial = isPartial,
 674 | +
 675 | +			};
 676 | +
 677 | +			TypeAttributes typeAttributes;
 678 | +			if (isPublic)
 679 | +				typeAttributes = isNested ? TypeAttributes.NestedPublic : TypeAttributes.Public;
 680 | +			else
 681 | +				typeAttributes = isNested ? TypeAttributes.NestedPrivate : TypeAttributes.NotPublic;
 682 | +
 683 | +			ret.TypeAttributes = (ret.TypeAttributes & ~TypeAttributes.VisibilityMask) | typeAttributes;
 684 | +			if (isSealed)
 685 | +				ret.TypeAttributes |= TypeAttributes.Sealed;
 686 | +
 687 | +			return ret;
 688 | +		}
 689 | +
 690 | +		CodeTypeDeclaration AddLayoutClass (CodeTypeDeclaration outerClass, string className, string parentType)
 691 | +		{
 692 | +			CodeTypeDeclaration klass = CreateLayoutClass (outerClass, className, parentType);
 693 | +			outerClass.Members.Add (klass);
 694 | +			return klass;
 695 | +		}
 696 | +
 697 | +		CodeTypeDeclaration CreateLayoutClass (CodeTypeDeclaration mainClass, string className, string parentType)
 698 | +		{
 699 | +			CodeTypeDeclaration ret = CreateClass (className, isPartial: false, isPublic: true, isNested: true, isSealed: true);
 700 | +
 701 | +			var mainClassTypeRef = new CodeTypeReference (parentType);
 702 | +			ret.Members.Add (new CodeMemberField (mainClassTypeRef, ChildClassParentFieldName));
 703 | +
 704 | +			var constructor = new CodeConstructor {
 705 | +				Attributes = MemberAttributes.Public,
 706 | +			};
 707 | +			constructor.Parameters.Add (new CodeParameterDeclarationExpression (mainClassTypeRef, ChildClassParentFieldName));
 708 | +
 709 | +			var assignParent = new CodeAssignStatement (
 710 | +				new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), ChildClassParentFieldName),
 711 | +				new CodeVariableReferenceExpression (ChildClassParentFieldName)
 712 | +			);
 713 | +			constructor.Statements.Add (assignParent);
 714 | +
 715 | +			ret.Members.Add (constructor);
 716 | +
 717 | +			return ret;
 718 | +		}
 719 | +
 720 | +		CodeTypeDeclaration AddMainClass (ITaskItem layoutFile, CodeNamespace ns, string className)
 721 | +		{
 722 | +			CodeTypeDeclaration klass = CreateMainClass (layoutFile, className);
 723 | +			klass.UserData [UserDataIsMainKey] = true;
 724 | +			ns.Types.Add (klass);
 725 | +			return klass;
 726 | +		}
 727 | +
 728 | +		CodeTypeDeclaration CreateMainClass (ITaskItem layoutFile, string className)
 729 | +		{
 730 | +			var ret = CreateClass (className, isPartial: true, isPublic: true);
 731 | +
 732 | +			AddComment (ret.Comments, $"Generated from layout file '{layoutFile.ItemSpec}'");
 733 | +			AddCommonMembers (ret, layoutFile);
 734 | +
 735 | +			return ret;
 736 | +		}
 737 | +
 738 | +		void AddCommonMembers (CodeTypeDeclaration klass, ITaskItem layoutFile)
 739 | +		{
 740 | +			var activityTypeRef = new CodeTypeReference ("Android.App.Activity", CodeTypeReferenceOptions.GlobalReference);
 741 | +
 742 | +			klass.Members.Add (new CodeMemberField (new CodeTypeReference (typeof (bool)), "__throwOnMissingView_LayoutCodeBehind"));
 743 | +			klass.Members.Add (ImplementInitializeContentView (layoutFile));
 744 | +			klass.Members.Add (ImplementFindView (new CodeTypeReference ("Android.Views.View", CodeTypeReferenceOptions.GlobalReference)));
 745 | +			klass.Members.Add (ImplementFindView (activityTypeRef));
 746 | +			klass.Members.Add (ImplementFindView (new CodeTypeReference ("Android.App.Fragment", CodeTypeReferenceOptions.GlobalReference), activityTypeRef, (CodeVariableReferenceExpression parentView) => new CodePropertyReferenceExpression (parentView, "Activity")));
 747 | +			klass.Members.Add (ImplementEnsureView ());
 748 | +			klass.Members.Add (new CodeSnippetTypeMember ("\tpartial void OnLayoutViewNotFound (int resourceId, Type type);"));
 749 | +		}
 750 | +
 751 | +		CodeMemberMethod ImplementInitializeContentView (ITaskItem layoutFile)
 752 | +		{
 753 | +			CodeMemberMethod method = CreateMethod ("InitializeContentView", MethodAccessibility.Private, MethodScope.Final);
 754 | +			method.Parameters.Add (new CodeParameterDeclarationExpression (typeof (bool), "throwOnMissingView = false"));
 755 | +
 756 | +			var assignThrowOnMissingView = new CodeAssignStatement (
 757 | +				new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), "__throwOnMissingView_LayoutCodeBehind"),
 758 | +				new CodeVariableReferenceExpression ("throwOnMissingView")
 759 | +			);
 760 | +			method.Statements.Add (assignThrowOnMissingView);
 761 | +
 762 | +			// SetContentView (Resource.Layout.Main);
 763 | +			string layoutResourceName = $"Resource.Layout.{Path.GetFileNameWithoutExtension (layoutFile.ItemSpec)}";
 764 | +			var methodInvoke = new CodeMethodInvokeExpression (
 765 | +				new CodeThisReferenceExpression (),
 766 | +				"SetContentView",
 767 | +				new[] { new CodeSnippetExpression (layoutResourceName) }
 768 | +			);
 769 | +
 770 | +			method.Statements.Add (new CodeExpressionStatement (methodInvoke));
 771 | +			return method;
 772 | +		}
 773 | +
 774 | +		CodeMemberMethod ImplementEnsureView ()
 775 | +		{
 776 | +			CodeMemberMethod method = CreateMethod ("__EnsureView", MethodAccessibility.Private, MethodScope.Final);
 777 | +
 778 | +			// T __EnsureView <T> (Func<T> creator, ref T field) where T: class
 779 | +			var typeParam = new CodeTypeParameter ("T");
 780 | +			typeParam.Constraints.Add (" class"); // Hack: CodeDOM doesn't support the "class" constraint
 781 | +							      // and not passing the leading whitespace would result
 782 | +							      // in @class being output in generated code
 783 | +			method.TypeParameters.Add (typeParam);
 784 | +
 785 | +			var tRef = new CodeTypeReference (typeParam);
 786 | +			var funcRef = new CodeTypeReference (typeof(Func<>));
 787 | +			funcRef.TypeArguments.Add (tRef);
 788 | +			method.Parameters.Add (new CodeParameterDeclarationExpression (funcRef, "creator"));
 789 | +
 790 | +			method.Parameters.Add (
 791 | +				new CodeParameterDeclarationExpression (tRef, "field") {
 792 | +					Direction = FieldDirection.Ref
 793 | +				}
 794 | +			);
 795 | +			method.ReturnType = tRef;
 796 | +
 797 | +			// if (field != null)
 798 | +			//    return field;
 799 | +			var fieldVarRef = new CodeVariableReferenceExpression ("field");
 800 | +			var ifFieldNotNull = new CodeConditionStatement (
 801 | +				new CodeBinaryOperatorExpression (fieldVarRef, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
 802 | +				new[] { new CodeMethodReturnStatement (fieldVarRef) }
 803 | +			);
 804 | +			method.Statements.Add (ifFieldNotNull);
 805 | +
 806 | +			// if (creator == null)
 807 | +			//    throw new ArgumentNullException (nameof (creator));
 808 | +			var creatorVarRef = new CodeVariableReferenceExpression ("creator");
 809 | +			var argNullEx = new CodeThrowExceptionStatement (
 810 | +				new CodeObjectCreateExpression (
 811 | +					new CodeTypeReference (typeof (ArgumentNullException)),
 812 | +					new[] { new CodeSnippetExpression ("nameof (creator)") }
 813 | +				)
 814 | +			);
 815 | +			var ifCreatorNull = new CodeConditionStatement (
 816 | +				new CodeBinaryOperatorExpression (creatorVarRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression (null)),
 817 | +				new[] { argNullEx }
 818 | +			);
 819 | +			method.Statements.Add (ifCreatorNull);
 820 | +
 821 | +			// field = creator ();
 822 | +			method.Statements.Add (new CodeAssignStatement (fieldVarRef, new CodeDelegateInvokeExpression (creatorVarRef)));
 823 | +
 824 | +			// return field;
 825 | +			method.Statements.Add (new CodeMethodReturnStatement (fieldVarRef));
 826 | +			return method;
 827 | +		}
 828 | +
 829 | +		CodeMemberMethod ImplementFindView (CodeTypeReference typeForParent, CodeTypeReference typeForOverloadCall = null, Func<CodeVariableReferenceExpression, CodeExpression> constructParentViewCall = null)
 830 | +		{
 831 | +			CodeMemberMethod method = CreateMethod ("__FindView", MethodAccessibility.Private, MethodScope.Final);
 832 | +
 833 | +			// T __FindView<T> (int resourceId) where T: Android.Views.View
 834 | +			var typeParam = new CodeTypeParameter ("T");
 835 | +			typeParam.Constraints.Add (new CodeTypeReference ("Android.Views.View", CodeTypeReferenceOptions.GlobalReference));
 836 | +			method.TypeParameters.Add (typeParam);
 837 | +			method.Parameters.Add (new CodeParameterDeclarationExpression (typeForParent, "parentView"));
 838 | +			method.Parameters.Add (new CodeParameterDeclarationExpression (typeof(int), "resourceId"));
 839 | +
 840 | +			var tReference = new CodeTypeReference (typeParam);
 841 | +			method.ReturnType = tReference;
 842 | +
 843 | +			// T view = parentView.FindViewById<T> (resourceId);
 844 | +			var parentViewRef = new CodeVariableReferenceExpression ("parentView");
 845 | +			var resourceIdVarRef = new CodeVariableReferenceExpression ("resourceId");
 846 | +
 847 | +			if (typeForOverloadCall != null) {
 848 | +				var findViewRef = new CodeMethodReferenceExpression (
 849 | +					new CodeThisReferenceExpression (),
 850 | +					"__FindView",
 851 | +					new[] { tReference }
 852 | +				);
 853 | +
 854 | +				CodeExpression parentViewParam;
 855 | +				if (constructParentViewCall != null)
 856 | +					parentViewParam = constructParentViewCall (parentViewRef);
 857 | +				else
 858 | +					parentViewParam = parentViewRef;
 859 | +				var findViewCall = new CodeMethodInvokeExpression (findViewRef, new CodeExpression[] { parentViewParam, resourceIdVarRef });
 860 | +				method.Statements.Add (new CodeMethodReturnStatement (findViewCall));
 861 | +
 862 | +				return method;
 863 | +			}
 864 | +
 865 | +			var findByIdRef = new CodeMethodReferenceExpression (
 866 | +				parentViewRef,
 867 | +				"FindViewById",
 868 | +				new[] { tReference }
 869 | +			);
 870 | +
 871 | +			var findByIdInvoke = new CodeMethodInvokeExpression (findByIdRef, new[] { resourceIdVarRef });
 872 | +			var viewVar = new CodeVariableDeclarationStatement (tReference, "view", findByIdInvoke);
 873 | +			method.Statements.Add (viewVar);
 874 | +
 875 | +			// if (view == null) {
 876 | +			//    if (__throwOnMissingView_LayoutCodeBehind)
 877 | +			//        throw InvalidOperationException($"View not found (ID: {resourceId})");
 878 | +			//    else
 879 | +			//        OnLayoutViewNotFound (resourceId, typeof (T));
 880 | +			//
 881 | +			var throwInvOp = new CodeThrowExceptionStatement (
 882 | +				new CodeObjectCreateExpression (
 883 | +					new CodeTypeReference (typeof (InvalidOperationException)),
 884 | +					new[] { new CodeSnippetExpression ("$\"View not found (ID: {resourceId})\"") }
 885 | +				)
 886 | +			);
 887 | +
 888 | +			var viewNotFoundInvoke = new CodeMethodInvokeExpression (
 889 | +				new CodeThisReferenceExpression (),
 890 | +				"OnLayoutViewNotFound",
 891 | +				new CodeExpression[] { resourceIdVarRef, new CodeTypeOfExpression (tReference) }
 892 | +			);
 893 | +
 894 | +			var ifThrow = new CodeConditionStatement (
 895 | +				new CodeVariableReferenceExpression ("__throwOnMissingView_LayoutCodeBehind"),
 896 | +				new[] { throwInvOp },
 897 | +				new[] { new CodeExpressionStatement (viewNotFoundInvoke) }
 898 | +			);
 899 | +			var viewVarRef = new CodeVariableReferenceExpression ("view");
 900 | +			var ifViewNull = new CodeConditionStatement (
 901 | +				new CodeBinaryOperatorExpression (viewVarRef, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)),
 902 | +				new[] { ifThrow }
 903 | +			);
 904 | +			method.Statements.Add (ifViewNull);
 905 | +
 906 | +			// return view;
 907 | +			method.Statements.Add (new CodeMethodReturnStatement (viewVarRef));
 908 | +
 909 | +			return method;
 910 | +		}
 911 | +
 912 | +		CodeMemberMethod CreateMethod (string methodName, MethodAccessibility access, MethodScope scope)
 913 | +		{
 914 | +			return CreateMethod (methodName, access, scope, (CodeTypeReference)null);
 915 | +		}
 916 | +
 917 | +		CodeMemberMethod CreateMethod (string methodName, MethodAccessibility access, MethodScope scope, Type returnType)
 918 | +		{
 919 | +			return CreateMethod (methodName, access, scope, new CodeTypeReference (returnType));
 920 | +		}
 921 | +
 922 | +		CodeMemberMethod CreateMethod (string methodName, MethodAccessibility access, MethodScope scope, string returnType)
 923 | +		{
 924 | +			return CreateMethod (methodName, access, scope, new CodeTypeReference (returnType));
 925 | +		}
 926 | +
 927 | +		CodeMemberMethod CreateMethod (string methodName, MethodAccessibility access, MethodScope scope, CodeTypeReference returnType)
 928 | +		{
 929 | +			var ret = new CodeMemberMethod {
 930 | +				Name = methodName,
 931 | +			};
 932 | +			if (returnType != null)
 933 | +				ret.ReturnType = returnType;
 934 | +
 935 | +			MemberAttributes attrs;
 936 | +			switch (access) {
 937 | +				case MethodAccessibility.Internal:
 938 | +					attrs = MemberAttributes.FamilyAndAssembly;
 939 | +					break;
 940 | +
 941 | +				case MethodAccessibility.Private:
 942 | +					attrs = MemberAttributes.Private;
 943 | +					break;
 944 | +
 945 | +				case MethodAccessibility.Protected:
 946 | +					attrs = MemberAttributes.Family;
 947 | +					break;
 948 | +
 949 | +				case MethodAccessibility.Public:
 950 | +					attrs = MemberAttributes.Public;
 951 | +					break;
 952 | +
 953 | +				default:
 954 | +					throw new NotSupportedException ($"Method accessibility {access} is not supported");
 955 | +			}
 956 | +
 957 | +			if ((scope & MethodScope.Static) == MethodScope.Static) {
 958 | +				attrs |= MemberAttributes.Static | MemberAttributes.Final;
 959 | +			} else if ((scope & MethodScope.Abstract) == MethodScope.Abstract) {
 960 | +				attrs |= MemberAttributes.Abstract;
 961 | +			} else {
 962 | +				if ((scope & MethodScope.Override) == MethodScope.Override) {
 963 | +					attrs |= MemberAttributes.Override;
 964 | +				} else if ((scope & MethodScope.Virtual) == MethodScope.Virtual) {
 965 | +				} else {
 966 | +					attrs |= MemberAttributes.Final;
 967 | +				}
 968 | +			}
 969 | +
 970 | +			ret.Attributes = attrs;
 971 | +			return ret;
 972 | +		}
 973 | +
 974 | +		void AddComment (CodeCommentStatementCollection comments, string comment)
 975 | +		{
 976 | +			comments.Add (new CodeCommentStatement (comment));
 977 | +		}
 978 | +
 979 | +		void MarkAsCompilerGenerated (CodeTypeMember member)
 980 | +		{
 981 | +			AddCustomAttribute (member.CustomAttributes, typeof (CompilerGeneratedAttribute));
 982 | +		}
 983 | +
 984 | +		void AddCustomAttribute (CodeAttributeDeclarationCollection attributes, Type type)
 985 | +		{
 986 | +			attributes.Add (new CodeAttributeDeclaration (new CodeTypeReference (type)));
 987 | +		}
 988 | +	}
 989 | +}
 990 | diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
 991 | index 2324bb5..78107d1 100644
 992 | --- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
 993 | +++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj
 994 | @@ -519,6 +519,8 @@
 995 |      <Compile Include="Utilities\Profile.cs" />
 996 |      <None Include="Xamarin.Android.Build.Tasks.targets" />
 997 |      <Compile Include="Linker\MonoDroid.Tuner\PreserveTlsProvider.cs" />
 998 | +    <Compile Include="Tasks\GenerateLayoutsCodeBehind.cs" />
 999 | +    <Compile Include="Tasks\FindLayoutsWithCodeBehind.cs" />
1000 |    </ItemGroup>
1001 |    <!-- MD doesn't handle MSBuildToolsPath yet
1002 |    <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
1003 | diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
1004 | index 2959b8c..46faf8e 100755
1005 | --- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
1006 | +++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets
1007 | @@ -91,6 +91,8 @@ Copyright (C) 2011-2012 Xamarin. All rights reserved.
1008 |  <UsingTask TaskName="Xamarin.Android.Tasks.Proguard" AssemblyFile="Xamarin.Android.Build.Tasks.dll" />
1009 |  <UsingTask TaskName="Xamarin.Android.Tasks.DetermineJavaLibrariesToCompile" AssemblyFile="Xamarin.Android.Build.Tasks.dll" />
1010 |  <UsingTask TaskName="Xamarin.Android.Tasks.CreateMultiDexMainDexClassList" AssemblyFile="Xamarin.Android.Build.Tasks.dll" />
1011 | +<UsingTask TaskName="Xamarin.Android.Tasks.GenerateLayoutsCodeBehind" AssemblyFile="Xamarin.Android.Build.Tasks.dll" />
1012 | +<UsingTask TaskName="Xamarin.Android.Tasks.FindLayoutsWithCodeBehind" AssemblyFile="Xamarin.Android.Build.Tasks.dll" />
1013 |  
1014 |  <!--
1015 |  *******************************************
1016 | @@ -948,6 +950,7 @@ because xbuild doesn't support framework reference assemblies.
1017 |  	<MonoAndroidIntermediateAssemblyTempDir>$(IntermediateOutputPath)linkdst\</MonoAndroidIntermediateAssemblyTempDir>
1018 |  	<MonoAndroidResourcePrefix Condition="'$(MonoAndroidResourcePrefix)' == ''">Resources</MonoAndroidResourcePrefix>
1019 |  	<MonoAndroidIntermediate>$(IntermediateOutputPath)</MonoAndroidIntermediate>
1020 | +  <MonoAndroidCodeBehindDir>$(MonoAndroidIntermediate)codebehind</MonoAndroidCodeBehindDir>
1021 |  	<MonoAndroidIntermediateResourceCache>$(IntermediateOutputPath)resourcecache</MonoAndroidIntermediateResourceCache>
1022 |  	<_AndroidAotBinDirectory>$(IntermediateOutputPath)aot</_AndroidAotBinDirectory>
1023 |  	<_AndroidResgenFlagFile>$(IntermediateOutputPath)R.cs.flag</_AndroidResgenFlagFile>
1024 | @@ -1028,6 +1031,29 @@ because xbuild doesn't support framework reference assemblies.
1025 |  	<MakeDir Directories="$(MonoAndroidResDirIntermediate)" />
1026 |  </Target>
1027 |  
1028 | +<Target Name="_FindLayoutsWithCodeBehind">
1029 | +  <FindLayoutsWithCodeBehind ResourceFiles="@(AndroidResource)" ExplicitFile="$(_ExplicitCodeBehindLayout)">
1030 | +    <Output ItemName="_LayoutWithCodeBehind" TaskParameter="LayoutFiles" />
1031 | +  </FindLayoutsWithCodeBehind>
1032 | +</Target>
1033 | +
1034 | +<Target Name="_GenerateLayoutsCodeBehind"
1035 | +        DependsOnTargets="_FindLayoutsWithCodeBehind"
1036 | +        Inputs="@(_LayoutWithCodeBehind)"
1037 | +        Outputs="@(_LayoutWithCodeBehind->'$(MonoAndroidCodeBehindDir)\%(CodeBehindFileName)')">
1038 | +  <MakeDir Directories="$(MonoAndroidCodeBehindDir)" Condition="!Exists('$(MonoAndroidCodeBehindDir)')"/>
1039 | +	<GenerateLayoutsCodeBehind LayoutFiles="@(_LayoutWithCodeBehind)" CodeBehindFiles="@(_LayoutWithCodeBehind->'$(MonoAndroidCodeBehindDir)\%(CodeBehindFileName)')"/>
1040 | +</Target>
1041 | +
1042 | +<Target
1043 | +    Name="_IncludeLayoutsCodeBehindSources"
1044 | +    DependsOnTargets="_GenerateLayoutsCodeBehind">
1045 | +  <Message Text="Including generated layout code-behind files in build: @(_LayoutWithCodeBehind->'$(MonoAndroidCodeBehindDir)\%(CodeBehindFileName)')"/>
1046 | +  <ItemGroup>
1047 | +    <Compile Include="@(_LayoutWithCodeBehind->'$(MonoAndroidCodeBehindDir)\%(CodeBehindFileName)')"/>
1048 | +  </ItemGroup>
1049 | +</Target>
1050 | +
1051 |  <Target Name="_GenerateAndroidResourceDir"
1052 |  	Inputs="$(MSBuildAllProjects);@(AndroidResource);$(_AndroidBuildPropertiesCache)"
1053 |  	Outputs="@(_AndroidResourceDest)"
1054 | @@ -1234,6 +1260,7 @@ because xbuild doesn't support framework reference assemblies.
1055 |  		_GetAdditionalResourcesFromAssemblies;
1056 |  		_CreateAdditionalResourceCache;
1057 |  		_GenerateAndroidResourceDir;
1058 | +    _IncludeLayoutsCodeBehindSources;
1059 |  	</_UpdateAndroidResgenDependsOnTargets>
1060 |  </PropertyGroup>
1061 |  
1062 | 


--------------------------------------------------------------------------------