From 740b9038f5f70a716f0ff559674552efe6e87573 Mon Sep 17 00:00:00 2001
From: Samantha Houts <samhouts@users.noreply.github.com>
Date: Thu, 7 Mar 2019 14:44:10 -0800
Subject: [PATCH 01/25] [Maps} move design dll to the design folder (#5481)

- fixes #5472
---
 .nuspec/Xamarin.Forms.Maps.nuspec | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.nuspec/Xamarin.Forms.Maps.nuspec b/.nuspec/Xamarin.Forms.Maps.nuspec
index 06fb167df9b..183bd665fb6 100644
--- a/.nuspec/Xamarin.Forms.Maps.nuspec
+++ b/.nuspec/Xamarin.Forms.Maps.nuspec
@@ -65,8 +65,8 @@
     <file src="..\docs\Xamarin.Forms.Maps.xml" target="lib\tizen40" />
 
     <!-- Xaml Design-time Stuff -->
-    <file src="..\Xamarin.Forms.Maps.Design\bin\$Configuration$\Xamarin.Forms.Maps.Design.dll" target="lib\netstandard2.0" />
-    <file src="..\Xamarin.Forms.Maps.Design\bin\$Configuration$\Xamarin.Forms.Maps.Design.dll" target="lib\netstandard1.0" />
+    <file src="..\Xamarin.Forms.Maps.Design\bin\$Configuration$\Xamarin.Forms.Maps.Design.dll" target="lib\netstandard2.0\Design" />
+    <file src="..\Xamarin.Forms.Maps.Design\bin\$Configuration$\Xamarin.Forms.Maps.Design.dll" target="lib\netstandard1.0\Design" />
 
 </files>
 </package>

From b5c8345fa80bcfa50401d97085d76b3e1c168808 Mon Sep 17 00:00:00 2001
From: Akihiko Odaki <akihiko.odaki.4i@stu.hosei.ac.jp>
Date: Mon, 11 Mar 2019 17:52:36 +0900
Subject: [PATCH 02/25] [XamlC] Fix message for unresolved event handler
 reference in DataTemplate (#5502)

---
 Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs b/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
index c02070bfcff..f704bf0bd20 100644
--- a/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
+++ b/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
@@ -933,7 +933,7 @@ static IEnumerable<Instruction> ConnectEvent(VariableDefinition parent, string l
 				declaringType = declaringType.DeclaringType;
 			var handler = declaringType.AllMethods().FirstOrDefault(md => md.Name == value as string);
 			if (handler == null) 
-				throw new XamlParseException($"EventHandler \"{value}\" not found in type \"{context.Body.Method.DeclaringType.FullName}\"", iXmlLineInfo);
+				throw new XamlParseException($"EventHandler \"{value}\" not found in type \"{declaringType}\"", iXmlLineInfo);
 
 			//check if the handler signature matches the Invoke signature;
 			var invoke = module.ImportReference(eventinfo.EventType.ResolveCached().GetMethods().First(md => md.Name == "Invoke"));

From 9af95f0399e34f4dac40a64d102ec43bfe67831b Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Mon, 11 Mar 2019 14:38:34 +0100
Subject: [PATCH 03/25] [X] recover from missing markup type (#5485)

- fixes #5484
---
 .../DesignTimeLoaderTests.cs                  |  8 +++--
 Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs    | 14 ++++++---
 Xamarin.Forms.Xaml/XamlServiceProvider.cs     | 30 ++++++-------------
 3 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs b/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
index 4b1d76b9e1c..d450bc5a85c 100644
--- a/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
+++ b/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
@@ -559,8 +559,12 @@ public void IgnoreMarkupExtensionException()
 		{
 			var xaml = @"
 						<ContentPage xmlns=""http://xamarin.com/schemas/2014/forms""
-							xmlns:x=""http://schemas.microsoft.com/winfx/2009/xaml"">
-							<ListView ItemsSource=""{x:Static Foo}"" />
+							xmlns:x=""http://schemas.microsoft.com/winfx/2009/xaml""
+								xmlns:local=""clr-namespace:Xamarin.Forms.Xaml.UnitTests;assembly=Xamarin.Forms.Xaml.UnitTests"">
+								<StackLayout>
+									<ListView ItemsSource=""{x:Static Foo}"" />
+									<ListView ItemsSource=""{local:Missing Test}"" />
+								</StackLayout>
 						</ContentPage>";
 
 			var exceptions = new List<Exception>();
diff --git a/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs b/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs
index 104657e27c9..0296222f341 100644
--- a/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs
+++ b/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs
@@ -92,13 +92,13 @@ INode ParseExpression(ref string expression, IXmlNamespaceResolver nsResolver, I
 			var serviceProvider = new XamlServiceProvider(node, Context);
 			serviceProvider.Add(typeof (IXmlNamespaceResolver), nsResolver);
 
-			return new MarkupExpansionParser().Parse(match, ref expression, serviceProvider);
+			return new MarkupExpansionParser { ExceptionHandler = Context.ExceptionHandler}.Parse(match, ref expression, serviceProvider);
 		}
 
 		public class MarkupExpansionParser : MarkupExpressionParser, IExpressionParser<INode>
 		{
 			IElementNode node;
-
+			internal Action<Exception> ExceptionHandler { get; set; }
 			object IExpressionParser.Parse(string match, ref string remaining, IServiceProvider serviceProvider)
 			{
 				return Parse(match, ref remaining, serviceProvider);
@@ -137,8 +137,14 @@ public INode Parse(string match, ref string remaining, IServiceProvider serviceP
 				else
 				{
 					//The order of lookup is to look for the Extension-suffixed class name first and then look for the class name without the Extension suffix.
-					if (!typeResolver.TryResolve(match + "Extension", out type) && !typeResolver.TryResolve(match, out type))
-						throw new XamlParseException($"MarkupExtension not found for {match}", serviceProvider);
+					if (!typeResolver.TryResolve(match + "Extension", out type) && !typeResolver.TryResolve(match, out type)) {
+						var ex = new XamlParseException($"MarkupExtension not found for {match}", serviceProvider);
+						if (ExceptionHandler != null) {
+							ExceptionHandler(ex);
+							return null;
+						}
+						throw ex;
+					}
 				}
 
 				var namespaceuri = nsResolver.LookupNamespace(prefix) ?? "";
diff --git a/Xamarin.Forms.Xaml/XamlServiceProvider.cs b/Xamarin.Forms.Xaml/XamlServiceProvider.cs
index 127d76d7fd2..2992d2a98af 100644
--- a/Xamarin.Forms.Xaml/XamlServiceProvider.cs
+++ b/Xamarin.Forms.Xaml/XamlServiceProvider.cs
@@ -201,19 +201,13 @@ internal XamlTypeResolver(IXmlNamespaceResolver namespaceResolver, GetTypeFromXm
 			Assembly currentAssembly)
 		{
 			this.currentAssembly = currentAssembly;
-			if (namespaceResolver == null)
-				throw new ArgumentNullException();
-			if (getTypeFromXmlName == null)
-				throw new ArgumentNullException();
-
-			this.namespaceResolver = namespaceResolver;
-			this.getTypeFromXmlName = getTypeFromXmlName;
+			this.namespaceResolver = namespaceResolver ?? throw new ArgumentNullException();
+			this.getTypeFromXmlName = getTypeFromXmlName ?? throw new ArgumentNullException();
 		}
 
 		Type IXamlTypeResolver.Resolve(string qualifiedTypeName, IServiceProvider serviceProvider)
 		{
-			XamlParseException e;
-			var type = Resolve(qualifiedTypeName, serviceProvider, out e);
+			var type = Resolve(qualifiedTypeName, serviceProvider, out XamlParseException e);
 			if (e != null)
 				throw e;
 			return type;
@@ -221,8 +215,7 @@ Type IXamlTypeResolver.Resolve(string qualifiedTypeName, IServiceProvider servic
 
 		bool IXamlTypeResolver.TryResolve(string qualifiedTypeName, out Type type)
 		{
-			XamlParseException exception;
-			type = Resolve(qualifiedTypeName, null, out exception);
+			type = Resolve(qualifiedTypeName, null, out XamlParseException exception);
 			return exception == null;
 		}
 
@@ -234,28 +227,23 @@ Type Resolve(string qualifiedTypeName, IServiceProvider serviceProvider, out Xam
 				return null;
 
 			string prefix, name;
-			if (split.Length == 2)
-			{
+			if (split.Length == 2) {
 				prefix = split[0];
 				name = split[1];
 			}
-			else
-			{
+			else {
 				prefix = "";
 				name = split[0];
 			}
 
 			IXmlLineInfo xmlLineInfo = null;
-			if (serviceProvider != null)
-			{
-				var lineInfoProvider = serviceProvider.GetService(typeof (IXmlLineInfoProvider)) as IXmlLineInfoProvider;
-				if (lineInfoProvider != null)
+			if (serviceProvider != null) {
+				if (serviceProvider.GetService(typeof(IXmlLineInfoProvider)) is IXmlLineInfoProvider lineInfoProvider)
 					xmlLineInfo = lineInfoProvider.XmlLineInfo;
 			}
 
 			var namespaceuri = namespaceResolver.LookupNamespace(prefix);
-			if (namespaceuri == null)
-			{
+			if (namespaceuri == null) {
 				exception = new XamlParseException(string.Format("No xmlns declaration for prefix \"{0}\"", prefix), xmlLineInfo);
 				return null;
 			}

From 9146b1d986511556d1b454830ec7b6c926467750 Mon Sep 17 00:00:00 2001
From: Shane Neuville <shane94@hotmail.com>
Date: Mon, 11 Mar 2019 14:45:38 -0600
Subject: [PATCH 04/25] Fix up Sandbox to work with previewer and add android
 material reference in (#5513)

* fix sandbox to work with previewer

* small page fixes
---
 Xamarin.Forms.Sandbox.Android/MainActivity.cs             | 5 +++--
 .../Xamarin.Forms.Sandbox.Android.csproj                  | 4 ++++
 .../Xamarin.Forms.Sandbox.iOS.csproj                      | 4 ++++
 Xamarin.Forms.Sandbox/App.StartHere.cs                    | 7 ++-----
 Xamarin.Forms.Sandbox/MainPage.xaml                       | 6 ++++--
 Xamarin.Forms.Sandbox/Xamarin.Forms.Sandbox.csproj        | 8 ++------
 6 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/Xamarin.Forms.Sandbox.Android/MainActivity.cs b/Xamarin.Forms.Sandbox.Android/MainActivity.cs
index bd16617e3cb..1f7693aadc5 100644
--- a/Xamarin.Forms.Sandbox.Android/MainActivity.cs
+++ b/Xamarin.Forms.Sandbox.Android/MainActivity.cs
@@ -18,8 +18,9 @@ protected override void OnCreate(Bundle savedInstanceState)
             ToolbarResource = Resource.Layout.Toolbar;
 
             base.OnCreate(savedInstanceState);
-            global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
-            LoadApplication(new App());
+			global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
+			global::Xamarin.Forms.FormsMaterial.Init(this, savedInstanceState);
+			LoadApplication(new App());
         }
     }
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Sandbox.Android/Xamarin.Forms.Sandbox.Android.csproj b/Xamarin.Forms.Sandbox.Android/Xamarin.Forms.Sandbox.Android.csproj
index 861c5f2b26b..73262d13fb7 100644
--- a/Xamarin.Forms.Sandbox.Android/Xamarin.Forms.Sandbox.Android.csproj
+++ b/Xamarin.Forms.Sandbox.Android/Xamarin.Forms.Sandbox.Android.csproj
@@ -101,6 +101,10 @@
       <Project>{6e53feb1-1100-46ae-8013-17bba35cc197}</Project>
       <Name>Xamarin.Forms.Platform.Android (Forwarders)</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Xamarin.Forms.Material.Android\Xamarin.Forms.Material.Android.csproj">
+      <Project>{e1586ce6-8eac-4388-a15a-1aabf108b5f8}</Project>
+      <Name>Xamarin.Forms.Material.Android</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Xamarin.Forms.Platform.Android.FormsViewGroup\Xamarin.Forms.Platform.Android.FormsViewGroup.csproj">
       <Project>{3b72465b-acae-43ae-9327-10f372fe5f80}</Project>
       <Name>Xamarin.Forms.Platform.Android.FormsViewGroup</Name>
diff --git a/Xamarin.Forms.Sandbox.iOS/Xamarin.Forms.Sandbox.iOS.csproj b/Xamarin.Forms.Sandbox.iOS/Xamarin.Forms.Sandbox.iOS.csproj
index 61ffdda2d5f..3d4d6fb0e0f 100644
--- a/Xamarin.Forms.Sandbox.iOS/Xamarin.Forms.Sandbox.iOS.csproj
+++ b/Xamarin.Forms.Sandbox.iOS/Xamarin.Forms.Sandbox.iOS.csproj
@@ -184,6 +184,10 @@
       <Project>{e155c410-e5de-464d-9ed7-2b1e672438ed}</Project>
       <Name>Xamarin.Forms.Sandbox</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Xamarin.Forms.Xaml\Xamarin.Forms.Xaml.csproj">
+      <Project>{9db2f292-8034-4e06-89ad-98bbda4306b9}</Project>
+      <Name>Xamarin.Forms.Xaml</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Xamarin.iOS.MaterialComponents">
diff --git a/Xamarin.Forms.Sandbox/App.StartHere.cs b/Xamarin.Forms.Sandbox/App.StartHere.cs
index 20b21e55d38..69a99b85590 100644
--- a/Xamarin.Forms.Sandbox/App.StartHere.cs
+++ b/Xamarin.Forms.Sandbox/App.StartHere.cs
@@ -9,11 +9,8 @@ public partial class App
 		// This code is called from the App Constructor so just initialize the main page of the application here
 		void InitializeMainPage()
 		{
-			/*MainPage = new ContentPage()
-			{
-				Content = CreateStackLayout(new[] { new Button() { Text = "text" } })
-			};
-			MainPage.Visual = VisualMarker.Material;*/
+			//MainPage = CreateStackLayoutPage(new[] { new Button() { Text = "text" } });
+			//MainPage.Visual = VisualMarker.Material;
 			MainPage = new MainPage();
 		}
 	}
diff --git a/Xamarin.Forms.Sandbox/MainPage.xaml b/Xamarin.Forms.Sandbox/MainPage.xaml
index 0f0af41b359..c105aa29d58 100644
--- a/Xamarin.Forms.Sandbox/MainPage.xaml
+++ b/Xamarin.Forms.Sandbox/MainPage.xaml
@@ -1,10 +1,12 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
              xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             x:Class="Xamarin.Forms.Sandbox.MainPage">
+             x:Class="Xamarin.Forms.Sandbox.MainPage"
+             xmlns:ios="clr-namespace:Xamarin.Forms.PlatformConfiguration.iOSSpecific;assembly=Xamarin.Forms.Core" 
+             ios:Page.UseSafeArea="true">
     <ContentPage.Content>
         <StackLayout>
-            <Button Text="Material text" Visual="MaTeRiAl" />
+            <Button Text="I am a Button"  />
         </StackLayout>
     </ContentPage.Content>
 </ContentPage>
\ No newline at end of file
diff --git a/Xamarin.Forms.Sandbox/Xamarin.Forms.Sandbox.csproj b/Xamarin.Forms.Sandbox/Xamarin.Forms.Sandbox.csproj
index 378e35303f2..dca9fb7a0a4 100644
--- a/Xamarin.Forms.Sandbox/Xamarin.Forms.Sandbox.csproj
+++ b/Xamarin.Forms.Sandbox/Xamarin.Forms.Sandbox.csproj
@@ -16,17 +16,13 @@
   
   <ItemGroup>
     <!-- A reference to the entire .NET Framework is automatically included -->
+    <ProjectReference ReferenceOutputAssembly="False" Include="..\Xamarin.Forms.Build.Tasks\Xamarin.Forms.Build.Tasks.csproj" />
     <ProjectReference Include="..\Xamarin.Forms.Core\Xamarin.Forms.Core.csproj" />
     <ProjectReference Include="..\Xamarin.Forms.CustomAttributes\Xamarin.Forms.CustomAttributes.csproj" />
     <ProjectReference Include="..\Xamarin.Forms.Maps\Xamarin.Forms.Maps.csproj" />
     <ProjectReference Include="..\Xamarin.Forms.Xaml\Xamarin.Forms.Xaml.csproj" />
   </ItemGroup>
-  
-  <ItemGroup>
-    <EmbeddedResource Update="Page1.xaml">
-      <Generator>MSBuild:UpdateDesignTimeXaml</Generator>
-    </EmbeddedResource>
-  </ItemGroup>
+
   <Import Project="..\.nuspec\Xamarin.Forms.targets" Condition="'$(BuildingInsideVisualStudio)' == 'true' AND Exists('$(__XFBuildTasksLocation)Xamarin.Forms.Build.Tasks.dll')" />
   <Import Project="..\.nuspec\Xamarin.Forms.targets" Condition="'$(BuildingInsideVisualStudio)' != 'true'" />
 </Project>
\ No newline at end of file

From e434184f64ac8b7339fe38190e10ff68a00aaacb Mon Sep 17 00:00:00 2001
From: Tim Barham <tim.barham@microsoft.com>
Date: Wed, 13 Mar 2019 07:36:12 +1000
Subject: [PATCH 05/25] Fix NamedSize in Previewer (#5496)

In the previewer, ConvertTextAppearanceToSize() returns -0.5 for all values. Return default value if we get a size of 0 or less.
---
 Xamarin.Forms.Platform.Android/Forms.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Xamarin.Forms.Platform.Android/Forms.cs b/Xamarin.Forms.Platform.Android/Forms.cs
index b52f4c1d30c..6ce33745bf0 100644
--- a/Xamarin.Forms.Platform.Android/Forms.cs
+++ b/Xamarin.Forms.Platform.Android/Forms.cs
@@ -549,9 +549,9 @@ double ConvertTextAppearanceToSize(int themeDefault, int deviceDefault, double d
 			{
 				double myValue;
 
-				if (TryGetTextAppearance(themeDefault, out myValue))
+				if (TryGetTextAppearance(themeDefault, out myValue) && myValue > 0)
 					return myValue;
-				if (TryGetTextAppearance(deviceDefault, out myValue))
+				if (TryGetTextAppearance(deviceDefault, out myValue) && myValue > 0)
 					return myValue;
 				return defaultValue;
 			}

From 7d8b2fc0e5eed1f5712fc58c8ecb99f192870273 Mon Sep 17 00:00:00 2001
From: Akihiko Odaki <akihiko.odaki.4i@stu.hosei.ac.jp>
Date: Fri, 22 Feb 2019 09:56:42 +0900
Subject: [PATCH 06/25] [XamlC] Identify generic instance types correctly when
 importing ctor (#5309)

The old implementation fails to identify generic instance types for typed
binding getter, whose type is:
System.Func`2<TSource, ValueTuple<TProperty, bool>>

This fixes the issue by taking generic arguments into account.
---
 .../ModuleDefinitionExtensions.cs             | 11 +++-
 .../XamlC/ModuleDefinitionExtensionsTests.cs  | 62 +++++++++++++++++++
 2 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 Xamarin.Forms.Xaml.UnitTests/XamlC/ModuleDefinitionExtensionsTests.cs

diff --git a/Xamarin.Forms.Build.Tasks/ModuleDefinitionExtensions.cs b/Xamarin.Forms.Build.Tasks/ModuleDefinitionExtensions.cs
index 29693e815b0..b8e08ad8ccb 100644
--- a/Xamarin.Forms.Build.Tasks/ModuleDefinitionExtensions.cs
+++ b/Xamarin.Forms.Build.Tasks/ModuleDefinitionExtensions.cs
@@ -47,7 +47,7 @@ static MethodReference ImportCtorReference(this ModuleDefinition module, TypeRef
 
 		public static MethodReference ImportCtorReference(this ModuleDefinition module, TypeReference type, TypeReference[] parameterTypes)
 		{
-			var ctorKey = $"{type}.ctor({(parameterTypes == null ? "" : string.Join(",", parameterTypes.Select(tr => (tr.Scope.Name, tr.Namespace, tr.Name))))})";
+			var ctorKey = $"{type}.ctor({(parameterTypes == null ? "" : string.Join(",", parameterTypes.Select(SerializeTypeReference)))})";
 			if (MethodRefCache.TryGetValue((module, ctorKey), out var ctorRef))
 				return ctorRef;
 			ctorRef = module.ImportCtorReference(type, classArguments: null, predicate: md => {
@@ -88,7 +88,7 @@ public static MethodReference ImportCtorReference(this ModuleDefinition module,
 
 		public static MethodReference ImportCtorReference(this ModuleDefinition module, (string assemblyName, string clrNamespace, string typeName) type, int paramCount, TypeReference[] classArguments)
 		{
-			var ctorKey = $"{type}<{(string.Join(",", classArguments.Select(tr => (tr.Scope.Name, tr.Namespace, tr.Name))))}>.ctor({(string.Join(",", Enumerable.Repeat("_", paramCount)))})";
+			var ctorKey = $"{type}<{string.Join(",", classArguments.Select(SerializeTypeReference))}>.ctor({(string.Join(",", Enumerable.Repeat("_", paramCount)))})";
 			if (!MethodRefCache.TryGetValue((module, ctorKey), out var ctorRef))
 				MethodRefCache.Add((module, ctorKey), ctorRef = module.ImportCtorReference(module.GetTypeDefinition(type), classArguments, predicate: md => md.Parameters.Count == paramCount));
 			return ctorRef;
@@ -303,5 +303,12 @@ static IEnumerable<PropertyDefinition> Properties(this TypeDefinition typedef, b
 			foreach (var property in typedef.BaseType.ResolveCached().Properties(true))
 				yield return property;
 		}
+
+		static string SerializeTypeReference(TypeReference tr)
+		{
+			var serialized = $"{tr.Scope.Name},{tr.Namespace},{tr.Name}";
+			var gitr = tr as GenericInstanceType;
+			return gitr == null ? serialized : $"{serialized}<{string.Join(",", gitr.GenericArguments.Select(SerializeTypeReference))}>";
+		}
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Xaml.UnitTests/XamlC/ModuleDefinitionExtensionsTests.cs b/Xamarin.Forms.Xaml.UnitTests/XamlC/ModuleDefinitionExtensionsTests.cs
new file mode 100644
index 00000000000..5fb3719a2d6
--- /dev/null
+++ b/Xamarin.Forms.Xaml.UnitTests/XamlC/ModuleDefinitionExtensionsTests.cs
@@ -0,0 +1,62 @@
+using System;
+using NUnit.Framework;
+using Mono.Cecil;
+using Xamarin.Forms.Build.Tasks;
+
+namespace Xamarin.Forms.XamlcUnitTests
+{
+	[TestFixture]
+	public class ModuleDefinitionExtensionsTests
+	{
+		class WithGenericInstanceCtorParameter
+		{
+			public WithGenericInstanceCtorParameter(Tuple<byte> argument)
+			{
+			}
+
+			public WithGenericInstanceCtorParameter(Tuple<short> argument)
+			{
+			}
+		}
+
+		ModuleDefinition module;
+
+		[SetUp]
+		public void SetUp()
+		{
+			var resolver = new XamlCAssemblyResolver();
+			resolver.AddAssembly(Uri.UnescapeDataString((new UriBuilder(typeof(ModuleDefinitionExtensionsTests).Assembly.CodeBase)).Path));
+			resolver.AddAssembly(Uri.UnescapeDataString((new UriBuilder(typeof(byte).Assembly.CodeBase)).Path));
+
+			module = ModuleDefinition.CreateModule("foo", new ModuleParameters {
+				AssemblyResolver = resolver,
+				Kind = ModuleKind.Dll
+			});
+		}
+
+		[Test]
+		public void TestImportCtorReferenceWithGenericInstanceCtorParameter()
+		{
+			var type = module.ImportReference(typeof(WithGenericInstanceCtorParameter));
+			var byteTuple = module.ImportReference(typeof(Tuple<byte>));
+			var byteTupleCtor = module.ImportCtorReference(type, new[] { byteTuple });
+			var int16Tuple = module.ImportReference(typeof(Tuple<short>));
+			var int16TupleCtor = module.ImportCtorReference(type, new[] { int16Tuple });
+
+			Assert.AreEqual("System.Tuple`1<System.Byte>", byteTupleCtor.Parameters[0].ParameterType.FullName);
+			Assert.AreEqual("System.Tuple`1<System.Int16>", int16TupleCtor.Parameters[0].ParameterType.FullName);
+		}
+
+		[Test]
+		public void TestImportCtorReferenceWithGenericInstanceTypeParameter()
+		{
+			var byteTuple = module.ImportReference(typeof(Tuple<byte>));
+			var byteTupleCtor = module.ImportCtorReference(("mscorlib", "System", "Tuple`1"), 1, new[] { byteTuple });
+			var in16Tuple = module.ImportReference(typeof(Tuple<short>));
+			var int16TupleCtor = module.ImportCtorReference(("mscorlib", "System", "Tuple`1"), 1, new[] { in16Tuple });
+
+			Assert.AreEqual("System.Tuple`1<System.Byte>", ((GenericInstanceType)byteTupleCtor.DeclaringType).GenericArguments[0].FullName);
+			Assert.AreEqual("System.Tuple`1<System.Int16>", ((GenericInstanceType)int16TupleCtor.DeclaringType).GenericArguments[0].FullName);
+		}
+	}
+}

From c4585a7588bc83bcf38bccf49c3b61eb8a43c56f Mon Sep 17 00:00:00 2001
From: Pavel Yakovlev <v-payako@microsoft.com>
Date: Wed, 13 Mar 2019 02:58:05 +0300
Subject: [PATCH 07/25] [UWP] added Win2D.uwp dependency to nuget (#5475)

fixes #5188
---
 .nuspec/Xamarin.Forms.nuspec | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.nuspec/Xamarin.Forms.nuspec b/.nuspec/Xamarin.Forms.nuspec
index 844377c340c..bea1e8f0c6b 100644
--- a/.nuspec/Xamarin.Forms.nuspec
+++ b/.nuspec/Xamarin.Forms.nuspec
@@ -31,6 +31,7 @@
       <group targetFramework="uap10.0">
         <dependency id="NETStandard.Library" version="2.0.1"/>
         <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="6.0.12" />
+        <dependency id="Win2D.uwp" version="1.20.0" />
       </group>
       <group targetFramework="tizen40">
         <dependency id="Tizen.NET" version="4.0.0"/>

From 339bd2bc822a5d3d5c094d0c0ae4f4843dbd042c Mon Sep 17 00:00:00 2001
From: spruceDevelopment <33689503+spruceDevelopment@users.noreply.github.com>
Date: Wed, 13 Mar 2019 12:39:58 +0100
Subject: [PATCH 08/25] Correct Grid Height When Aspect Fit Image Gets Shrinked
  (#4990)

- fixes #4933

* Grid size incorrect when using with Image #4990

* Unit Test for Grid size incorrect when using with Image #4933

* Grid size incorrect when using with Image #4933

* Unit Test for Grid size incorrect when using with Image #4933
---
 .../Issue4493.cs                              | 32 +++++++++++++++++++
 ...rin.Forms.Controls.Issues.Shared.projitems |  1 +
 Xamarin.Forms.Core.UnitTests/GridTests.cs     | 22 +++++++++++++
 Xamarin.Forms.Core/GridCalc.cs                |  6 ++--
 4 files changed, 58 insertions(+), 3 deletions(-)
 create mode 100644 Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4493.cs

diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4493.cs b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4493.cs
new file mode 100644
index 00000000000..4bf122e12ba
--- /dev/null
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4493.cs
@@ -0,0 +1,32 @@
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms.Controls.Issues
+{
+	[Preserve(AllMembers = true)]
+	[Issue(IssueTracker.Github, 4933, "Grid size incorrect when using with Image", PlatformAffected.All)]
+	public class Issue4493 : TestContentPage // or TestMasterDetailPage, etc ...
+	{
+		protected override void Init()
+		{
+			// Initialize ui here instead of ctor
+			BackgroundColor = Color.Gray;
+			var contentGrid = new Grid
+			{
+				AutomationId = "IssuePageGrid",
+				HorizontalOptions = LayoutOptions.FillAndExpand,
+				VerticalOptions = LayoutOptions.Center,
+				BackgroundColor = Color.Maroon,
+				RowSpacing = 0,
+				RowDefinitions = new RowDefinitionCollection()
+				{
+					new RowDefinition(){Height = GridLength.Auto},
+					new RowDefinition(){Height = 20}
+				}
+			};
+			contentGrid.AddChild(new Image() { Source = "photo.jpg", AutomationId = "IssuePageImage" }, 0, 0);
+			contentGrid.AddChild(new Label() { Text = "test message", BackgroundColor = Color.Blue }, 0, 1);
+			Content = contentGrid;
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
index a04970f46c2..3cac75c0a87 100644
--- a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
@@ -890,6 +890,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Issue4138.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue4314.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue3318.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Issue4493.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue5172.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Xamarin.Forms.Core.UnitTests/GridTests.cs b/Xamarin.Forms.Core.UnitTests/GridTests.cs
index 700a4ad4aee..ed9a6a0b6de 100644
--- a/Xamarin.Forms.Core.UnitTests/GridTests.cs
+++ b/Xamarin.Forms.Core.UnitTests/GridTests.cs
@@ -1519,6 +1519,28 @@ public void InvalidationBlockedForAbsoluteCell ()
 			Assert.False (invalidated);
 		}
 
+
+		[Test]
+		//https://github.com/xamarin/Xamarin.Forms/issues/4933
+		public void GridHeightCorrectWhenAspectFitImageGetsShrinked()
+		{
+			var contentGrid = new Grid
+			{
+				HorizontalOptions = LayoutOptions.FillAndExpand,
+				VerticalOptions = LayoutOptions.Center,
+				RowDefinitions = new RowDefinitionCollection()
+				{
+					new RowDefinition(){Height = GridLength.Auto}
+				}
+			};
+			//image will have "EVERYTHING IS 100 x 20" size so grid should shrink it and itself to 50x10
+			contentGrid.Children.Add(new Image() { IsPlatformEnabled = true }, 0, 0);
+			var measurement = contentGrid.Measure(50, 100);
+			Assert.AreEqual(50, measurement.Request.Width);
+			Assert.AreEqual(10, measurement.Request.Height);
+		}
+
+
 		// because the constraint is internal, we need this
 		public enum HackLayoutConstraint
 		{
diff --git a/Xamarin.Forms.Core/GridCalc.cs b/Xamarin.Forms.Core/GridCalc.cs
index 4ff0e87173c..1f8deab19bf 100644
--- a/Xamarin.Forms.Core/GridCalc.cs
+++ b/Xamarin.Forms.Core/GridCalc.cs
@@ -374,7 +374,7 @@ void ExpandLastAutoRowIfNeeded(double height, bool expandToRequest)
 		void MeasureAndContractStarredColumns(double width, double height, double totalStarsWidth)
 		{
 			double starColWidth;
-			starColWidth = MeasuredStarredColumns();
+			starColWidth = MeasuredStarredColumns(width, height);
 
 			if (!double.IsPositiveInfinity(width) && double.IsPositiveInfinity(height))
 			{
@@ -426,7 +426,7 @@ void MeasureAndContractStarredRows(double width, double height, double totalStar
 			ContractRowsIfNeeded(height, r => r.Height.IsStar);
 		}
 
-		double MeasuredStarredColumns()
+		double MeasuredStarredColumns(double widthConstraint, double heightConstraint)
 		{
 			double starColWidth;
 			for (var iteration = 0; iteration < 2; iteration++)
@@ -450,7 +450,7 @@ double MeasuredStarredColumns()
 								continue;
 							double assignedWidth = GetAssignedColumnWidth(child);
 
-							SizeRequest sizeRequest = child.Measure(double.PositiveInfinity, double.PositiveInfinity, MeasureFlags.IncludeMargins);
+							SizeRequest sizeRequest = child.Measure(widthConstraint, heightConstraint, MeasureFlags.IncludeMargins);
 							actualWidth = Math.Max(actualWidth, sizeRequest.Request.Width - assignedWidth - (GetColumnSpan(child) - 1) * ColumnSpacing);
 							minimumWidth = Math.Max(minimumWidth, sizeRequest.Minimum.Width - assignedWidth - (GetColumnSpan(child) - 1) * ColumnSpacing);
 						}

From fa5c4fb371c2aff9e132f52013b4e59055d799cf Mon Sep 17 00:00:00 2001
From: Shane Neuville <shane94@hotmail.com>
Date: Wed, 13 Mar 2019 10:03:32 -0600
Subject: [PATCH 09/25] [Android] ensure scrollbar has been initialized (#5462)

* [Android] ensure scrollbar has been initialized

* fix comments

* Update Xamarin.Forms.ControlGallery.Android/CustomRenderers.cs
---
 .../CustomRenderers.cs                        | 11 ++++
 .../Issue5461.cs                              | 57 +++++++++++++++++++
 ...rin.Forms.Controls.Issues.Shared.projitems |  1 +
 .../Extensions/ScrollViewExtensions.cs        | 45 +++++++++++++++
 Xamarin.Forms.Platform.Android/IScrollView.cs | 21 +++++++
 .../Renderers/AHorizontalScrollView.cs        | 36 +++++++++++-
 .../Renderers/ScrollViewRenderer.cs           | 29 ++++++++--
 .../Xamarin.Forms.Platform.Android.csproj     |  2 +
 8 files changed, 196 insertions(+), 6 deletions(-)
 create mode 100644 Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5461.cs
 create mode 100644 Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs
 create mode 100644 Xamarin.Forms.Platform.Android/IScrollView.cs

diff --git a/Xamarin.Forms.ControlGallery.Android/CustomRenderers.cs b/Xamarin.Forms.ControlGallery.Android/CustomRenderers.cs
index 12750d398de..d5779e9d166 100644
--- a/Xamarin.Forms.ControlGallery.Android/CustomRenderers.cs
+++ b/Xamarin.Forms.ControlGallery.Android/CustomRenderers.cs
@@ -25,6 +25,7 @@
 using Xamarin.Forms.Controls.Issues;
 
 
+[assembly: ExportRenderer(typeof(Issue5461.ScrollbarFadingEnabledFalseScrollView), typeof(ScrollbarFadingEnabledFalseScrollViewRenderer))]
 [assembly: ExportRenderer(typeof(Issue1942.CustomGrid), typeof(Issue1942GridRenderer))]
 [assembly: ExportRenderer(typeof(Xamarin.Forms.Controls.Effects.AttachedStateEffectLabel), typeof(AttachedStateEffectLabelRenderer))]
 [assembly: ExportRenderer(typeof(Xamarin.Forms.Controls.LegacyComponents.NonAppCompatSwitch), typeof(NonAppCompatSwitchRenderer))]
@@ -58,6 +59,16 @@ public NonAppCompatSwitchRenderer(Context context) : base(context)
 		}
 	}
 
+	public class ScrollbarFadingEnabledFalseScrollViewRenderer : ScrollViewRenderer
+	{
+		public ScrollbarFadingEnabledFalseScrollViewRenderer(Context context) : base(context)
+		{
+			// I do a cast here just so this will fail just to be sure we don't change the base types
+			var castingTest = (global::Android.Support.V4.Widget.NestedScrollView)this;
+			castingTest.ScrollbarFadingEnabled = false;
+		}
+	}
+
 	public class AttachedStateEffectLabelRenderer : LabelRenderer
 	{
 		public AttachedStateEffectLabelRenderer(Context context) : base(context)
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5461.cs b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5461.cs
new file mode 100644
index 00000000000..7c6f7f982d0
--- /dev/null
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5461.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.Forms.Internals;
+
+
+#if UITEST
+using Xamarin.UITest;
+using NUnit.Framework;
+using Xamarin.Forms.Core.UITests;
+#endif
+
+namespace Xamarin.Forms.Controls.Issues
+{
+	[Preserve(AllMembers = true)]
+	[Issue(IssueTracker.Github, 5461, "[Android] ScrollView crashes when setting ScrollbarFadingEnabled to false in Custom Renderer",
+		PlatformAffected.Android)]
+#if UITEST
+	[NUnit.Framework.Category(UITestCategories.ScrollView)]
+#endif
+	public class Issue5461 : TestContentPage
+	{
+		const string Success = "If you can see this, the test has passed";
+		protected override void Init()
+		{
+			ScrollView scrollView = new ScrollbarFadingEnabledFalseScrollView()
+			{
+				Content = new StackLayout()
+				{
+					Children =
+					{
+						new Label()
+						{
+							Text = Success
+						}
+					},
+					HeightRequest = 2000
+				}
+			};
+
+			Content = scrollView;
+		}
+
+		public class ScrollbarFadingEnabledFalseScrollView : ScrollView { }
+
+
+#if UITEST && __ANDROID__
+		[Test]
+		public void ScrollViewWithScrollbarFadingEnabledFalseDoesntCrash()
+		{
+			RunningApp.WaitForElement(Success);
+		}
+#endif
+	}
+}
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
index ab05a3c5433..030bec7098e 100644
--- a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
@@ -14,6 +14,7 @@
       <DependentUpon>Bugzilla60787.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="$(MSBuildThisFileDirectory)Issue5461.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue2102.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue1588.xaml.cs">
       <DependentUpon>Issue1588.xaml</DependentUpon>
diff --git a/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs b/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs
new file mode 100644
index 00000000000..a392bb9efa9
--- /dev/null
+++ b/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Android.App;
+using Android.Content;
+using Android.OS;
+using Android.Runtime;
+using Android.Views;
+using Android.Widget;
+
+namespace Xamarin.Forms.Platform.Android
+{
+	internal static class ScrollViewExtensions
+	{
+		internal static void HandleScrollBarVisibilityChange(this IScrollView scrollView)
+		{
+
+			// According to the Android Documentation
+			// * <p>AwakenScrollBars method should be invoked every time a subclass directly updates
+			// *the scroll parameters.</ p >
+
+			// If AwakenScrollBars is never called there are cases where the ScrollDrawable is never called
+			// which causes a crash during draw
+
+			if (scrollView.ScrollBarsInitialized)
+				scrollView.AwakenScrollBars();
+
+			// The scrollbar drawable won't initialize if ScrollbarFadingEnabled == false
+			if (!scrollView.ScrollbarFadingEnabled)
+			{
+				scrollView.ScrollbarFadingEnabled = true;
+				scrollView.AwakenScrollBars();
+				scrollView.ScrollbarFadingEnabled = false;
+			}
+			else
+			{
+				scrollView.AwakenScrollBars();
+			}
+
+			scrollView.ScrollBarsInitialized = true;
+		}
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.Android/IScrollView.cs b/Xamarin.Forms.Platform.Android/IScrollView.cs
new file mode 100644
index 00000000000..46ff8f1ccce
--- /dev/null
+++ b/Xamarin.Forms.Platform.Android/IScrollView.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Android.App;
+using Android.Content;
+using Android.OS;
+using Android.Runtime;
+using Android.Views;
+using Android.Widget;
+
+namespace Xamarin.Forms.Platform.Android
+{
+	internal interface IScrollView
+	{
+		bool ScrollBarsInitialized { get; set; }
+		bool ScrollbarFadingEnabled { get; set; }
+		void AwakenScrollBars();
+	}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs b/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs
index c02084be5ed..bb1aec74adb 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs
@@ -1,11 +1,12 @@
 using Android.Content;
 using Android.Support.V4.Widget;
+using Android.Graphics;
 using Android.Views;
 using Android.Widget;
 
 namespace Xamarin.Forms.Platform.Android
 {
-	public class AHorizontalScrollView : HorizontalScrollView
+	public class AHorizontalScrollView : HorizontalScrollView, IScrollView
 	{
 		readonly ScrollViewRenderer _renderer;
 
@@ -68,5 +69,38 @@ protected override void OnScrollChanged(int l, int t, int oldl, int oldt)
 
 			_renderer.UpdateScrollPosition(Context.FromPixels(l), Context.FromPixels(t));
 		}
+
+		public override void Draw(Canvas canvas)
+		{
+			try
+			{
+				base.Draw(canvas);
+			}
+			catch (Java.Lang.NullPointerException npe)
+			when (npe.Message.Contains("ScrollBarDrawable.mutate()"))
+			{
+				// This will most likely never run since UpdateScrollBars is called 
+				// when the scrollbars visibilities are updated but I left it here
+				// just in case there's an edge case that causes an exception
+				this.HandleScrollBarVisibilityChange();
+			}
+		}
+
+		public override bool HorizontalScrollBarEnabled
+		{
+			get { return base.HorizontalScrollBarEnabled; }
+			set
+			{
+				base.HorizontalScrollBarEnabled = value;
+				this.HandleScrollBarVisibilityChange();
+			}
+		}
+
+		void IScrollView.AwakenScrollBars()
+		{
+			base.AwakenScrollBars();
+		}
+
+		bool IScrollView.ScrollBarsInitialized { get; set; } = false;
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs b/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs
index f80ef5f916a..f45b98a3728 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs
@@ -8,12 +8,11 @@
 using Android.Views;
 using Android.Widget;
 using Xamarin.Forms.Internals;
-using AScrollView = Android.Widget.ScrollView;
 using AView = Android.Views.View;
 
 namespace Xamarin.Forms.Platform.Android
 {
-	public class ScrollViewRenderer : NestedScrollView, IVisualElementRenderer, IEffectControlProvider
+	public class ScrollViewRenderer : NestedScrollView, IVisualElementRenderer, IEffectControlProvider, IScrollView
 	{
 		ScrollViewContainer _container;
 		HorizontalScrollView _hScrollView;
@@ -138,9 +137,20 @@ public void UpdateLayout()
 
 		public override void Draw(Canvas canvas)
 		{
-			canvas.ClipRect(canvas.ClipBounds);
+			try
+			{
+				canvas.ClipRect(canvas.ClipBounds);
 
-			base.Draw(canvas);
+				base.Draw(canvas);
+			}
+			catch (Java.Lang.NullPointerException npe)
+			when(npe.Message.Contains("ScrollBarDrawable.mutate()"))
+			{
+				// This will most likely never run since UpdateScrollBars is called 
+				// when the scrollbars visibilities are updated but I left it here
+				// just in case there's an edge case that causes an exception
+				this.HandleScrollBarVisibilityChange();
+			}
 		}
 
 		public override bool OnInterceptTouchEvent(MotionEvent ev)
@@ -498,7 +508,7 @@ void UpdateHorizontalScrollBarVisibility()
 					newHorizontalScrollVisiblility = _defaultHorizontalScrollVisibility;
 				}
 
-				_hScrollView.HorizontalScrollBarEnabled = newHorizontalScrollVisiblility == ScrollBarVisibility.Always;
+				_hScrollView.HorizontalScrollBarEnabled = newHorizontalScrollVisiblility == ScrollBarVisibility.Always;				
 			}
 		}
 
@@ -513,6 +523,15 @@ void UpdateVerticalScrollBarVisibility()
 				newVerticalScrollVisibility = _defaultVerticalScrollVisibility;
 
 			VerticalScrollBarEnabled = newVerticalScrollVisibility == ScrollBarVisibility.Always;
+
+			this.HandleScrollBarVisibilityChange();
 		}
+
+		void IScrollView.AwakenScrollBars()
+		{
+			base.AwakenScrollBars();
+		}
+
+		bool IScrollView.ScrollBarsInitialized { get; set; } = false;
 	}
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj b/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj
index 41320d370ad..5e50e1c1842 100644
--- a/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj
+++ b/Xamarin.Forms.Platform.Android/Xamarin.Forms.Platform.Android.csproj
@@ -100,6 +100,7 @@
     <Compile Include="Elevation.cs" />
     <Compile Include="Extensions\EntryRendererExtensions.cs" />
     <Compile Include="Extensions\FragmentManagerExtensions.cs" />
+    <Compile Include="Extensions\ScrollViewExtensions.cs" />
     <Compile Include="FastRenderers\AutomationPropertiesProvider.cs" />
     <Compile Include="AppCompat\PageExtensions.cs" />
     <Compile Include="Extensions\JavaObjectExtensions.cs" />
@@ -145,6 +146,7 @@
     <Compile Include="IBorderVisualElementRenderer.cs" />
     <Compile Include="IDeviceInfoProvider.cs" />
     <Compile Include="ILayoutChanges.cs" />
+    <Compile Include="IScrollView.cs" />
     <Compile Include="ITabStop.cs" />
     <Compile Include="IPickerRenderer.cs" />
     <Compile Include="PickerManager.cs" />

From 1c53e66f87eccedad5c6a40fb1d4683a2a8ceedb Mon Sep 17 00:00:00 2001
From: Andrei Nitescu <nitescua@yahoo.com>
Date: Wed, 13 Mar 2019 21:24:22 +0200
Subject: [PATCH 10/25] Fix Map ItemsSource bp name (#5499)

---
 Xamarin.Forms.Maps/Map.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Xamarin.Forms.Maps/Map.cs b/Xamarin.Forms.Maps/Map.cs
index f881c197a5f..a62cdee137f 100644
--- a/Xamarin.Forms.Maps/Map.cs
+++ b/Xamarin.Forms.Maps/Map.cs
@@ -18,7 +18,7 @@ public class Map : View, IEnumerable<Pin>
 
 		public static readonly BindableProperty HasZoomEnabledProperty = BindableProperty.Create("HasZoomEnabled", typeof(bool), typeof(Map), true);
 
-		public static readonly BindableProperty ItemsSourceProperty = BindableProperty.Create(nameof(IEnumerable), typeof(IEnumerable), typeof(Map), default(IEnumerable),
+		public static readonly BindableProperty ItemsSourceProperty = BindableProperty.Create(nameof(ItemsSource), typeof(IEnumerable), typeof(Map), default(IEnumerable),
 			propertyChanged: (b, o, n) => ((Map)b).OnItemsSourcePropertyChanged((IEnumerable)o, (IEnumerable)n));
 
 		public static readonly BindableProperty ItemTemplateProperty = BindableProperty.Create(nameof(ItemTemplate), typeof(DataTemplate), typeof(Map), default(DataTemplate),

From 362a9b200ac425fa04ab4c39ff90f53b08d60936 Mon Sep 17 00:00:00 2001
From: Samantha Houts <samhouts@users.noreply.github.com>
Date: Wed, 13 Mar 2019 14:51:38 -0700
Subject: [PATCH 11/25] [Housekeeping] Be more polite (#5539)

---
 .../Xamarin.Forms.Controls.Issues.Shared/Issue4136.cs         | 4 ++--
 .../CoreGalleryPages/LabelCoreGalleryPage.cs                  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4136.cs b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4136.cs
index c3e20d55bbe..d70b183f2df 100644
--- a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4136.cs
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue4136.cs
@@ -23,7 +23,7 @@ protected override void Init()
 			{
 				LineBreakMode = LineBreakMode.WordWrap,
 				Text =
-					"Lorem ipsum dolor sit amet, cu mei malis petentium, dolor tempor delicata no qui, eos ex vitae utinam vituperata. Utroque habemus philosophia ut mei, doctus placerat eam cu. An inermis scaevola pro, quo legimus deleniti ei, equidem docendi urbanitas ea eum. Saepe doctus ut pri. Nec ex wisi dolorem. Duo dolor vituperatoribus ea. Id purto instructior per. Nec partem accusamus ne. Qui ad saepe accumsan appellantur, duis omnesque has et, vim nihil nemore scaevola ne. Ei populo appetere recteque cum, meliore splendide appellantur vix id."
+					"Lorem ipsum dolor sit amet, cu mei malis petentium, dolor tempor delicata no qui, eos ex vitae utinam vituperata. Utroque habemus philosophia ut mei, doctus placerat eam cu. An inermis scaevola pro, quo legimus deleniti ei, equidem docendi urbanitas ea eum. Saepe doctus ut pri. Nec ex wisi dolorem. Duo dolor vituperatoribus ea. Id purto instructior per. Nec partem accusamus ne. Qui ad saepe accumsan appellantur, duis omnesque has et, vim nihil nemore scaevola ne. Ei populo appetere recteque xum, meliore splendide appellantur vix id."
 			};
 
 			var spaced = new Label
@@ -31,7 +31,7 @@ protected override void Init()
 				LineHeight = 1.5,
 				LineBreakMode = LineBreakMode.WordWrap,
 				Text =
-					"Lorem ipsum dolor sit amet, cu mei malis petentium, dolor tempor delicata no qui, eos ex vitae utinam vituperata. Utroque habemus philosophia ut mei, doctus placerat eam cu. An inermis scaevola pro, quo legimus deleniti ei, equidem docendi urbanitas ea eum. Saepe doctus ut pri. Nec ex wisi dolorem. Duo dolor vituperatoribus ea. Id purto instructior per. Nec partem accusamus ne. Qui ad saepe accumsan appellantur, duis omnesque has et, vim nihil nemore scaevola ne. Ei populo appetere recteque cum, meliore splendide appellantur vix id."
+					"Lorem ipsum dolor sit amet, cu mei malis petentium, dolor tempor delicata no qui, eos ex vitae utinam vituperata. Utroque habemus philosophia ut mei, doctus placerat eam cu. An inermis scaevola pro, quo legimus deleniti ei, equidem docendi urbanitas ea eum. Saepe doctus ut pri. Nec ex wisi dolorem. Duo dolor vituperatoribus ea. Id purto instructior per. Nec partem accusamus ne. Qui ad saepe accumsan appellantur, duis omnesque has et, vim nihil nemore scaevola ne. Ei populo appetere recteque xum, meliore splendide appellantur vix id."
 			};
 
 			layout.Children.Add(instructions);
diff --git a/Xamarin.Forms.Controls/CoreGalleryPages/LabelCoreGalleryPage.cs b/Xamarin.Forms.Controls/CoreGalleryPages/LabelCoreGalleryPage.cs
index b12a8905b40..efcda811bb3 100644
--- a/Xamarin.Forms.Controls/CoreGalleryPages/LabelCoreGalleryPage.cs
+++ b/Xamarin.Forms.Controls/CoreGalleryPages/LabelCoreGalleryPage.cs
@@ -61,7 +61,7 @@ protected override void Build (StackLayout stackLayout)
 
 			var formattedTextContainer = new ViewContainer<Label>(Test.Label.FormattedText, new Label { FormattedText = formattedString });
 
-			const string longText = "Lorem ipsum dolor sit amet, cu mei malis petentium, dolor tempor delicata no qui, eos ex vitae utinam vituperata. Utroque habemus philosophia ut mei, doctus placerat eam cu. An inermis scaevola pro, quo legimus deleniti ei, equidem docendi urbanitas ea eum. Saepe doctus ut pri. Nec ex wisi dolorem. Duo dolor vituperatoribus ea. Id purto instructior per. Nec partem accusamus ne. Qui ad saepe accumsan appellantur, duis omnesque has et, vim nihil nemore scaevola ne. Ei populo appetere recteque cum, meliore splendide appellantur vix id.";
+			const string longText = "Lorem ipsum dolor sit amet, cu mei malis petentium, dolor tempor delicata no qui, eos ex vitae utinam vituperata. Utroque habemus philosophia ut mei, doctus placerat eam cu. An inermis scaevola pro, quo legimus deleniti ei, equidem docendi urbanitas ea eum. Saepe doctus ut pri. Nec ex wisi dolorem. Duo dolor vituperatoribus ea. Id purto instructior per. Nec partem accusamus ne. Qui ad saepe accumsan appellantur, duis omnesque has et, vim nihil nemore scaevola ne. Ei populo appetere recteque xum, meliore splendide appellantur vix id.";
 			var lineBreakModeCharacterWrapContainer = new ViewContainer<Label> (Test.Label.LineBreakModeCharacterWrap, new Label { Text = longText, LineBreakMode = LineBreakMode.CharacterWrap });
 			var lineBreakModeHeadTruncationContainer = new ViewContainer<Label> (Test.Label.LineBreakModeHeadTruncation, new Label { Text = longText, LineBreakMode = LineBreakMode.HeadTruncation });
 			var lineBreakModeMiddleTruncationContainer = new ViewContainer<Label> (Test.Label.LineBreakModeMiddleTruncation, new Label { Text = longText, LineBreakMode = LineBreakMode.MiddleTruncation });

From 263c9a9d6a342e50a725e8f5785a12ebac38a9b7 Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Thu, 14 Mar 2019 09:21:19 +0100
Subject: [PATCH 12/25] [X] resilience on markup (#5532)

let the previewer intercepts and recover from misformatted markups

- fixes #5508
- closes #5527
---
 .../DesignTimeLoaderTests.cs                  |  7 +++--
 Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs    | 27 +++++++++++++------
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs b/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
index d450bc5a85c..0023d0ac8b2 100644
--- a/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
+++ b/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
@@ -564,23 +564,22 @@ public void IgnoreMarkupExtensionException()
 								<StackLayout>
 									<ListView ItemsSource=""{x:Static Foo}"" />
 									<ListView ItemsSource=""{local:Missing Test}"" />
+									<Label Text=""{Binding Foo"" />
 								</StackLayout>
 						</ContentPage>";
-
 			var exceptions = new List<Exception>();
 			Xamarin.Forms.Internals.ResourceLoader.ExceptionHandler = exceptions.Add;
 			Assert.DoesNotThrow(() => XamlLoader.Create(xaml, true));
 			Assert.That(exceptions.Count, Is.GreaterThan(1));
-    }
+		}
 
-    [Test]
+		[Test]
 		public void CanResolveRootNode()
 		{
 			string assemblyName = null;
 			string clrNamespace = null;
 			string typeName = null;
 
-
 			XamlLoader.FallbackTypeResolver = (fallbackTypeInfos, type) =>
 			{
 				assemblyName = fallbackTypeInfos?[1].AssemblyName;
diff --git a/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs b/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs
index 0296222f341..6e60dcfaa67 100644
--- a/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs
+++ b/Xamarin.Forms.Xaml/ExpandMarkupsVisitor.cs
@@ -78,17 +78,28 @@ INode ParseExpression(ref string expression, IXmlNamespaceResolver nsResolver, I
 			if (expression.StartsWith("{}", StringComparison.Ordinal))
 				return new ValueNode(expression.Substring(2), null);
 
-			if (expression[expression.Length - 1] != '}')
-				throw new Exception("Expression must end with '}'");
+			if (expression[expression.Length - 1] != '}') {
+				var ex = new XamlParseException("Expression must end with '}'", xmlLineInfo);
+				if (Context.ExceptionHandler != null) {
+					Context.ExceptionHandler(ex);
+					return null;
+				}
+				throw ex;
+			}
 
-			int len;
-			string match;
-			if (!MarkupExpressionParser.MatchMarkup(out match, expression, out len))
+			if (!MarkupExpressionParser.MatchMarkup(out var match, expression, out var len))
 				throw new Exception();
-			expression = expression.Substring(len).TrimStart();
-			if (expression.Length == 0)
-				throw new Exception("Expression did not end in '}'");
 
+			expression = expression.Substring(len).TrimStart();
+			if (expression.Length == 0) {
+				var ex = new XamlParseException("Expression did not end in '}'", xmlLineInfo);
+				if (Context.ExceptionHandler != null)
+				{
+					Context.ExceptionHandler(ex);
+					return null;
+				}
+				throw ex;
+			}
 			var serviceProvider = new XamlServiceProvider(node, Context);
 			serviceProvider.Add(typeof (IXmlNamespaceResolver), nsResolver);
 

From 07ada19a7d67fd74451b09b751ff8bece9cf235b Mon Sep 17 00:00:00 2001
From: Seungkeun Lee <sngn.lee@samsung.com>
Date: Thu, 14 Mar 2019 20:14:06 +0900
Subject: [PATCH 13/25] [Tizen] Add CollectionView Tizen Renderer (#5364) fixes
 #3172

* [Tizen] Add CollectionView Tizen Renderer (#259)

* Tizen CollectionView implementation initial commit

 - first working version
 - only support LinearLayout(listview)

* Add more feature

 * Implement INotifyCollectionChanged
 * Implement EmptyView

* Implemnt SnapPoints, ScrollTo

* Fix MakeVisible option

* Add GridLayoutManager (#271)

* Fix GetScrollCanvasSize issue

* Enhance ItemAdaptor

 - Measure Item size with data binding
  Item size is determined with first item
 - Extract ItemDefaultTemplateAdaptor from ItemTemplateAdaptor

* Remove debug message

* Implement SelectableItemsView

* Fix ghost view issue

* Fix TV profile button effect issue

* Clean up code space and refactoring ScrollTo method

* Fix collectionView emptyview (#277)
---
 .../Native/CollectionView/CollectionView.cs   | 482 ++++++++++++++++++
 .../Native/CollectionView/EmptyItemAdaptor.cs |  61 +++
 .../CollectionView/GridLayoutManager.cs       | 256 ++++++++++
 .../ICollectionViewLayoutManager.cs           |  28 +
 .../Native/CollectionView/ItemAdaptor.cs      | 100 ++++
 .../CollectionView/ItemTemplateAdaptor.cs     | 112 ++++
 .../CollectionView/LinearLayoutManager.cs     | 240 +++++++++
 .../Native/CollectionView/RecyclerPool.cs     |  35 ++
 .../Native/CollectionView/ViewHolder.cs       | 171 +++++++
 .../Properties/AssemblyInfo.cs                |   1 +
 .../Renderers/ItemsViewRenderer.cs            | 182 +++++++
 .../Renderers/VisualElementRenderer.cs        |   4 +-
 12 files changed, 1670 insertions(+), 2 deletions(-)
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/CollectionView.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/EmptyItemAdaptor.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/GridLayoutManager.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/ICollectionViewLayoutManager.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemAdaptor.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemTemplateAdaptor.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/LinearLayoutManager.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/RecyclerPool.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Native/CollectionView/ViewHolder.cs
 create mode 100644 Xamarin.Forms.Platform.Tizen/Renderers/ItemsViewRenderer.cs

diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/CollectionView.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/CollectionView.cs
new file mode 100644
index 00000000000..573ea9f147a
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/CollectionView.cs
@@ -0,0 +1,482 @@
+using System;
+using System.Collections.Specialized;
+using ElmSharp;
+using EBox = ElmSharp.Box;
+using EScroller = ElmSharp.Scroller;
+using ESize = ElmSharp.Size;
+using EPoint = ElmSharp.Point;
+using System.Collections.Generic;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	public class CollectionView : EBox, ICollectionViewController
+	{
+		RecyclerPool _pool = new RecyclerPool();
+		ICollectionViewLayoutManager _layoutManager;
+		ItemAdaptor _adaptor;
+		EBox _innerLayout;
+
+		Dictionary<ViewHolder, int> _viewHolderIndexTable = new Dictionary<ViewHolder, int>();
+		ViewHolder _lastSelectedViewHolder;
+		int _selectedItemIndex = -1;
+		CollectionViewSelectionMode _selectionMode = CollectionViewSelectionMode.None;
+
+		bool _requestLayoutItems = false;
+		SnapPointsType _snapPoints;
+		ESize _itemSize = new ESize(-1, -1);
+
+		public CollectionView(EvasObject parent) : base(parent)
+		{
+			SetLayoutCallback(OnLayout);
+			Scroller = CreateScroller(parent);
+			Scroller.Show();
+			PackEnd(Scroller);
+			Scroller.Scrolled += OnScrolled;
+
+			_innerLayout = new EBox(parent);
+			_innerLayout.SetLayoutCallback(OnInnerLayout);
+			_innerLayout.Show();
+			Scroller.SetContent(_innerLayout);
+		}
+
+		public CollectionViewSelectionMode SelectionMode
+		{
+			get => _selectionMode;
+			set
+			{
+				_selectionMode = value;
+				UpdateSelectionMode();
+			}
+		}
+
+		public int SelectedItemIndex
+		{
+			get => _selectedItemIndex;
+			set
+			{
+				if (_selectedItemIndex != value)
+				{
+					_selectedItemIndex = value;
+					UpdateSelectedItemIndex();
+				}
+			}
+		}
+
+		public SnapPointsType SnapPointsType
+		{
+			get => _snapPoints;
+			set
+			{
+				_snapPoints = value;
+				UpdateSnapPointsType(_snapPoints);
+			}
+		}
+
+		protected EScroller Scroller { get; }
+
+		public ICollectionViewLayoutManager LayoutManager
+		{
+			get => _layoutManager;
+			set
+			{
+				OnLayoutManagerChanging();
+				_layoutManager = value;
+				OnLayoutManagerChanged();
+			}
+		}
+
+		public ItemAdaptor Adaptor
+		{
+			get => _adaptor;
+			set
+			{
+				OnAdaptorChanging();
+				_adaptor = value;
+				_adaptor.CollectionView = this;
+				OnAdaptorChanged();
+			}
+		}
+
+		int ICollectionViewController.Count => Adaptor?.Count ?? 0;
+
+		EPoint ICollectionViewController.ParentPosition => new EPoint
+		{
+			X = Scroller.Geometry.X - Scroller.CurrentRegion.X,
+			Y = Scroller.Geometry.Y - Scroller.CurrentRegion.Y
+		};
+
+		ESize AllocatedSize { get; set; }
+
+		Rect ViewPort => Scroller.CurrentRegion;
+
+		public void ScrollTo(int index, ScrollToPosition position = ScrollToPosition.MakeVisible, bool animate = true)
+		{
+			var itemBound = LayoutManager.GetItemBound(index);
+			int itemStart;
+			int itemEnd;
+			int scrollStart;
+			int scrollEnd;
+			int itemPadding = 0;
+			int itemSize;
+			int viewportSize;
+
+			if (LayoutManager.IsHorizontal)
+			{
+				itemStart = itemBound.Left;
+				itemEnd = itemBound.Right;
+				itemSize = itemBound.Width;
+				scrollStart = Scroller.CurrentRegion.Left;
+				scrollEnd = Scroller.CurrentRegion.Right;
+				viewportSize = AllocatedSize.Width;
+			}
+			else
+			{
+				itemStart = itemBound.Top;
+				itemEnd = itemBound.Bottom;
+				itemSize = itemBound.Height;
+				scrollStart = Scroller.CurrentRegion.Top;
+				scrollEnd = Scroller.CurrentRegion.Bottom;
+				viewportSize = AllocatedSize.Height;
+			}
+
+			if (position == ScrollToPosition.MakeVisible)
+			{
+				if (itemStart < scrollStart)
+				{
+					position = ScrollToPosition.Start;
+				}
+				else if (itemEnd > scrollEnd)
+				{
+					position = ScrollToPosition.End;
+				}
+				else
+				{
+					// already visible
+					return;
+				}
+			}
+
+			if (itemSize < viewportSize)
+			{
+				switch (position)
+				{
+					case ScrollToPosition.Center:
+						itemPadding = (viewportSize - itemSize) / 2;
+						break;
+					case ScrollToPosition.End:
+						itemPadding = (viewportSize - itemSize);
+						break;
+				}
+				itemSize = viewportSize;
+			}
+
+			if (LayoutManager.IsHorizontal)
+			{
+				itemBound.X -= itemPadding;
+				itemBound.Width = itemSize;
+			}
+			else
+			{
+				itemBound.Y -= itemPadding;
+				itemBound.Height = itemSize;
+			}
+
+			Scroller.ScrollTo(itemBound, animate);
+		}
+
+		public void ScrollTo(object item, ScrollToPosition position = ScrollToPosition.MakeVisible, bool animate = true)
+		{
+			ScrollTo(Adaptor.GetItemIndex(item), position, animate);
+		}
+
+		void ICollectionViewController.RequestLayoutItems() => RequestLayoutItems();
+
+
+		ESize ICollectionViewController.GetItemSize()
+		{
+			if (Adaptor == null)
+			{
+				return new ESize(0, 0);
+			}
+			if (_itemSize.Width > 0 && _itemSize.Height > 0)
+			{
+				return _itemSize;
+			}
+
+			_itemSize = Adaptor.MeasureItem(AllocatedSize.Width, AllocatedSize.Height);
+			_itemSize.Width = Math.Max(_itemSize.Width, 10);
+			_itemSize.Height = Math.Max(_itemSize.Height, 10);
+
+			if (_snapPoints != SnapPointsType.None)
+			{
+				Scroller.SetPageSize(_itemSize.Width, _itemSize.Height);
+			}
+			return _itemSize;
+		}
+
+		ViewHolder ICollectionViewController.RealizeView(int index)
+		{
+			if (Adaptor == null)
+				return null;
+
+			var holder = _pool.GetRecyclerView();
+			if (holder != null)
+			{
+				holder.Show();
+			}
+			else
+			{
+				var content = Adaptor.CreateNativeView(this);
+				holder = new ViewHolder(this);
+				holder.RequestSelected += OnRequestItemSelection;
+				holder.Content = content;
+				_innerLayout.PackEnd(holder);
+			}
+
+			Adaptor.SetBinding(holder.Content, index);
+			_viewHolderIndexTable[holder] = index;
+			if (index == SelectedItemIndex)
+			{
+				OnRequestItemSelection(holder, EventArgs.Empty);
+			}
+			return holder;
+		}
+
+		void OnRequestItemSelection(object sender, EventArgs e)
+		{
+			if (SelectionMode == CollectionViewSelectionMode.None)
+				return;
+
+
+			if (_lastSelectedViewHolder != null)
+			{
+				_lastSelectedViewHolder.State = ViewHolderState.Normal;
+			}
+
+			_lastSelectedViewHolder = sender as ViewHolder;
+			if (_lastSelectedViewHolder != null)
+			{
+				_lastSelectedViewHolder.State = ViewHolderState.Selected;
+				if (_viewHolderIndexTable.TryGetValue(_lastSelectedViewHolder, out int index))
+				{
+					_selectedItemIndex = index;
+					Adaptor?.SendItemSelected(index);
+				}
+			}
+		}
+
+		void ICollectionViewController.UnrealizeView(ViewHolder view)
+		{
+			_viewHolderIndexTable.Remove(view);
+			view.ResetState();
+			view.Hide();
+			_pool.AddRecyclerView(view);
+		}
+
+		protected virtual EScroller CreateScroller(EvasObject parent)
+		{
+			return new EScroller(parent);
+		}
+
+		void UpdateSelectedItemIndex()
+		{
+			if (SelectionMode == CollectionViewSelectionMode.None)
+				return;
+
+			ViewHolder holder = null;
+			foreach (var item in _viewHolderIndexTable)
+			{
+				if (item.Value == SelectedItemIndex)
+				{
+					holder = item.Key;
+					break;
+				}
+			}
+			OnRequestItemSelection(holder, EventArgs.Empty);
+		}
+
+		void UpdateSelectionMode()
+		{
+			if (SelectionMode == CollectionViewSelectionMode.None)
+			{
+				if (_lastSelectedViewHolder != null)
+				{
+					_lastSelectedViewHolder.State = ViewHolderState.Normal;
+					_lastSelectedViewHolder = null;
+				}
+				_selectedItemIndex = -1;
+			}
+		}
+
+
+		void OnLayoutManagerChanging()
+		{
+			_layoutManager?.Reset();
+		}
+
+		void OnLayoutManagerChanged()
+		{
+			if (_layoutManager == null)
+				return;
+
+			_layoutManager.CollectionView = this;
+			_layoutManager.SizeAllocated(AllocatedSize);
+			RequestLayoutItems();
+		}
+
+		void OnAdaptorChanging()
+		{
+			_layoutManager?.Reset();
+			if (Adaptor != null)
+			{
+				_pool.Clear(Adaptor);
+				(Adaptor as INotifyCollectionChanged).CollectionChanged -= OnCollectionChanged;
+				Adaptor.CollectionView = null;
+			}
+		}
+		void OnAdaptorChanged()
+		{
+			if (_adaptor == null)
+				return;
+
+			_itemSize = new ESize(-1, -1);
+			(Adaptor as INotifyCollectionChanged).CollectionChanged += OnCollectionChanged;
+
+			RequestLayoutItems();
+
+			if (LayoutManager != null)
+			{
+				var itemSize = (this as ICollectionViewController).GetItemSize();
+			}
+		}
+
+		void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+		{
+			if (e.Action == NotifyCollectionChangedAction.Add)
+			{
+				int idx = e.NewStartingIndex;
+				foreach (var item in e.NewItems)
+				{
+					LayoutManager.ItemInserted(idx++);
+				}
+			}
+			else if (e.Action == NotifyCollectionChangedAction.Remove)
+			{
+				int idx = e.OldStartingIndex;
+				foreach (var item in e.OldItems)
+				{
+					LayoutManager.ItemRemoved(idx);
+				}
+			}
+			else if (e.Action == NotifyCollectionChangedAction.Move)
+			{
+				LayoutManager.ItemRemoved(e.OldStartingIndex);
+				LayoutManager.ItemInserted(e.NewStartingIndex);
+			}
+			else if (e.Action == NotifyCollectionChangedAction.Replace)
+			{
+				LayoutManager.ItemUpdated(e.NewStartingIndex);
+			}
+			else if (e.Action == NotifyCollectionChangedAction.Reset)
+			{
+				LayoutManager.Reset();
+			}
+			RequestLayoutItems();
+		}
+
+		Rect _lastGeometry;
+		void OnLayout()
+		{
+			if (_lastGeometry == Geometry)
+			{
+				return;
+			}
+
+			_lastGeometry = Geometry;
+			Scroller.Geometry = Geometry;
+			Scroller.ScrollBlock = ScrollBlock.None;
+			AllocatedSize = Geometry.Size;
+			_itemSize = new ESize(-1, -1);
+
+			if (_adaptor != null && _layoutManager != null)
+			{
+				_layoutManager?.SizeAllocated(Geometry.Size);
+				_layoutManager?.LayoutItems(ViewPort);
+			}
+		}
+
+		void RequestLayoutItems()
+		{
+			if (!_requestLayoutItems)
+			{
+				_requestLayoutItems = true;
+				Device.BeginInvokeOnMainThread(() =>
+				{
+					_requestLayoutItems = false;
+					if (_adaptor != null && _layoutManager != null)
+					{
+						OnInnerLayout();
+						_layoutManager?.LayoutItems(ViewPort, true);
+					}
+				});
+			}
+		}
+
+		void OnInnerLayout()
+		{
+			var size = _layoutManager.GetScrollCanvasSize();
+			_innerLayout.MinimumWidth = size.Width;
+			_innerLayout.MinimumHeight = size.Height;
+		}
+
+		void OnScrolled(object sender, EventArgs e)
+		{
+			_layoutManager.LayoutItems(Scroller.CurrentRegion);
+		}
+
+		void UpdateSnapPointsType(SnapPointsType snapPoints)
+		{
+			var itemSize = new ESize(0, 0);
+			switch (snapPoints)
+			{
+				case SnapPointsType.None:
+					Scroller.HorizontalPageScrollLimit = 0;
+					Scroller.VerticalPageScrollLimit = 0;
+					break;
+				case SnapPointsType.MandatorySingle:
+					Scroller.HorizontalPageScrollLimit = 1;
+					Scroller.VerticalPageScrollLimit = 1;
+					itemSize = (this as ICollectionViewController).GetItemSize();
+					break;
+				case SnapPointsType.Mandatory:
+					Scroller.HorizontalPageScrollLimit = 0;
+					Scroller.VerticalPageScrollLimit = 0;
+					itemSize = (this as ICollectionViewController).GetItemSize();
+					break;
+			}
+			Scroller.SetPageSize(itemSize.Width, itemSize.Height);
+		}
+	}
+
+	public interface ICollectionViewController
+	{
+		EPoint ParentPosition { get; }
+
+		ViewHolder RealizeView(int index);
+
+		void UnrealizeView(ViewHolder view);
+
+		void RequestLayoutItems();
+
+		int Count { get; }
+
+		ESize GetItemSize();
+	}
+
+	public enum CollectionViewSelectionMode
+	{
+		None,
+		Single,
+	}
+
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/EmptyItemAdaptor.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/EmptyItemAdaptor.cs
new file mode 100644
index 00000000000..5aa6d6d0f53
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/EmptyItemAdaptor.cs
@@ -0,0 +1,61 @@
+using System.Collections;
+using System.Collections.Generic;
+
+using ESize = ElmSharp.Size;
+using XLabel = Xamarin.Forms.Label;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	public class EmptyItemAdaptor : ItemTemplateAdaptor
+	{
+		static DataTemplate s_defaultEmptyTemplate = new DataTemplate(typeof(EmptyView));
+		public EmptyItemAdaptor(ItemsView itemsView, IEnumerable items, DataTemplate template) : base(itemsView, items, template)
+		{
+		}
+
+		public static EmptyItemAdaptor Create(ItemsView itemsView)
+		{
+			DataTemplate template = null;
+			if (itemsView.EmptyView is View emptyView)
+			{
+				template = new DataTemplate(() =>
+				{
+					return emptyView;
+				});
+			}
+			else
+			{
+				template = itemsView.EmptyViewTemplate ?? s_defaultEmptyTemplate;
+			}
+			var empty = new List<object>
+			{
+				itemsView.EmptyView ?? new object()
+			};
+			return new EmptyItemAdaptor(itemsView, empty, template);
+		}
+
+		public override ElmSharp.Size MeasureItem(int widthConstraint, int heightConstraint)
+		{
+			return new ESize(widthConstraint, heightConstraint);
+		}
+
+		class EmptyView : StackLayout
+		{
+			public EmptyView()
+			{
+				HorizontalOptions = LayoutOptions.FillAndExpand;
+				VerticalOptions = LayoutOptions.FillAndExpand;
+				Children.Add(
+					new XLabel
+					{
+						Text = "No items found",
+						VerticalOptions = LayoutOptions.CenterAndExpand,
+						HorizontalOptions = LayoutOptions.CenterAndExpand,
+						HorizontalTextAlignment = Xamarin.Forms.TextAlignment.Center,
+						VerticalTextAlignment = Xamarin.Forms.TextAlignment.Center,
+					}
+				);
+			}
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/GridLayoutManager.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/GridLayoutManager.cs
new file mode 100644
index 00000000000..56f0090a7d6
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/GridLayoutManager.cs
@@ -0,0 +1,256 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ElmSharp;
+using ESize = ElmSharp.Size;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	public class GridLayoutManager : ICollectionViewLayoutManager
+	{
+		ESize _allocatedSize;
+		ESize _scrollCanvasSize;
+		bool _isLayouting;
+		Rect _last;
+		Dictionary<int, RealizedItem> _realizedItem = new Dictionary<int, RealizedItem>();
+
+		public GridLayoutManager(bool isHorizontal, int span = 1)
+		{
+			IsHorizontal = isHorizontal;
+			Span = span;
+		}
+
+		public int Span { get; internal set; }
+
+		public bool IsHorizontal { get; }
+
+		public ICollectionViewController CollectionView { get; set; }
+
+		public void SizeAllocated(ESize size)
+		{
+			Reset();
+			_allocatedSize = size;
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		public ESize GetScrollCanvasSize()
+		{
+			if (_scrollCanvasSize.Width > 0 && _scrollCanvasSize.Height > 0)
+				return _scrollCanvasSize;
+
+			var itemCount = CollectionView.Count;
+			var itemSize = CollectionView.GetItemSize();
+			if (IsHorizontal)
+			{
+				return _scrollCanvasSize = new ESize((int)Math.Ceiling(itemCount / (double)Span) * itemSize.Width , _allocatedSize.Height);
+			}
+			else
+			{
+				return _scrollCanvasSize = new ESize(_allocatedSize.Width, (int)Math.Ceiling(itemCount / (double)Span) * itemSize.Height);
+			}
+		}
+
+		bool ShouldRearrange(Rect viewport)
+		{
+			if (_isLayouting)
+				return false;
+			if (_last.Size != viewport.Size)
+				return true;
+
+			var diff = IsHorizontal ? Math.Abs(_last.X - viewport.X) : Math.Abs(_last.Y - viewport.Y);
+			var margin = IsHorizontal ? CollectionView.GetItemSize().Width : CollectionView.GetItemSize().Height;
+			if (diff > margin)
+				return true;
+
+			return false;
+		}
+
+		public void LayoutItems(Rect bound, bool force)
+		{
+			// TODO : need to optimization. it was frequently called with similar bound value.
+			if (!ShouldRearrange(bound) && !force)
+			{
+				return;
+			}
+			_isLayouting = true;
+			_last = bound;
+
+			var size = CollectionView.GetItemSize();
+			var itemSize = IsHorizontal ? size.Width : size.Height;
+
+			int padding = Span * 2;
+			int startIndex = Math.Max(GetStartIndex(bound, itemSize) - padding, 0);
+			int endIndex = Math.Min(GetEndIndex(bound, itemSize) + padding, CollectionView.Count - 1);
+
+			foreach (var index in _realizedItem.Keys.ToList())
+			{
+				if (index < startIndex || index > endIndex)
+				{
+					CollectionView.UnrealizeView(_realizedItem[index].View);
+					_realizedItem.Remove(index);
+				}
+			}
+
+			var parent = CollectionView.ParentPosition;
+			for (int i = startIndex; i <= endIndex; i++)
+			{
+				EvasObject itemView = null;
+				if (!_realizedItem.ContainsKey(i))
+				{
+					var view = CollectionView.RealizeView(i);
+
+					_realizedItem[i] = new RealizedItem
+					{
+						View = view,
+						Index = i,
+					};
+					itemView = view;
+				}
+				else
+				{
+					itemView = _realizedItem[i].View;
+				}
+
+				var itemBound = GetItemBound(i);
+				itemBound.X += parent.X;
+				itemBound.Y += parent.Y;
+				itemView.Geometry = itemBound;
+			}
+			_isLayouting = false;
+		}
+
+		public void UpdateSpan(int span)
+		{
+			Span = span;
+			_scrollCanvasSize = new ESize(0, 0);
+			CollectionView.RequestLayoutItems();
+		}
+
+		public void ItemInserted(int inserted)
+		{
+			var items = _realizedItem.Keys.OrderByDescending(key => key);
+			foreach (var index in items)
+			{
+				if (index >= inserted)
+				{
+					_realizedItem[index + 1] = _realizedItem[index];
+				}
+			}
+			if (_realizedItem.ContainsKey(inserted))
+			{
+				_realizedItem.Remove(inserted);
+			}
+			else
+			{
+				var last = items.LastOrDefault();
+				if (last >= inserted)
+				{
+					_realizedItem.Remove(last);
+				}
+			}
+
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		public void ItemRemoved(int removed)
+		{
+			if (_realizedItem.ContainsKey(removed))
+			{
+				CollectionView.UnrealizeView(_realizedItem[removed].View);
+				_realizedItem.Remove(removed);
+			}
+
+			var items = _realizedItem.Keys.OrderBy(key => key);
+			foreach (var index in items)
+			{
+				if (index > removed)
+				{
+					_realizedItem[index - 1] = _realizedItem[index];
+				}
+			}
+
+			var last = items.LastOrDefault();
+			if (last > removed)
+			{
+				_realizedItem.Remove(last);
+			}
+
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		public void ItemUpdated(int index)
+		{
+			if (_realizedItem.ContainsKey(index))
+			{
+				var bound = _realizedItem[index].View.Geometry;
+				CollectionView.UnrealizeView(_realizedItem[index].View);
+				var view = CollectionView.RealizeView(index);
+				_realizedItem[index].View = view;
+				view.Geometry = bound;
+			}
+		}
+
+		public Rect GetItemBound(int index)
+		{
+			var size = CollectionView.GetItemSize();
+			if (IsHorizontal)
+			{
+				size.Height = _allocatedSize.Height / Span;
+			}
+			else
+			{
+				size.Width = _allocatedSize.Width / Span;
+			}
+
+			int rowIndex = index / Span;
+			int colIndex = index % Span;
+			var colSize = IsHorizontal ? size.Height : size.Width;
+
+			return
+				IsHorizontal ?
+				new Rect(rowIndex * size.Width, colIndex * size.Height, size.Width, size.Height) :
+				new Rect(colIndex * size.Width, rowIndex * size.Height, size.Width, size.Height);
+		}
+
+		public void Reset()
+		{
+			foreach (var realizedItem in _realizedItem.Values)
+			{
+				CollectionView.UnrealizeView(realizedItem.View);
+			}
+			_realizedItem.Clear();
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		int GetStartIndex(Rect bound, int itemSize)
+		{
+			return ViewPortStartPoint(bound) / itemSize * Span;
+		}
+
+		int GetEndIndex(Rect bound, int itemSize)
+		{
+			return (int)Math.Ceiling(ViewPortEndPoint(bound) / (double)itemSize) * Span;
+		}
+
+		int ViewPortStartPoint(Rect viewPort)
+		{
+			return IsHorizontal ? viewPort.X : viewPort.Y;
+		}
+
+		int ViewPortEndPoint(Rect viewPort)
+		{
+			return ViewPortStartPoint(viewPort) + ViewPortSize(viewPort);
+		}
+
+		int ViewPortSize(Rect viewPort)
+		{
+			return IsHorizontal ? viewPort.Width : viewPort.Height;
+		}
+
+		class RealizedItem
+		{
+			public ViewHolder View { get; set; }
+			public int Index { get; set; }
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ICollectionViewLayoutManager.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ICollectionViewLayoutManager.cs
new file mode 100644
index 00000000000..dc7bf73ee91
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ICollectionViewLayoutManager.cs
@@ -0,0 +1,28 @@
+using ElmSharp;
+using ESize = ElmSharp.Size;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	public interface ICollectionViewLayoutManager
+	{
+		ICollectionViewController CollectionView { get; set; }
+
+		bool IsHorizontal { get; }
+
+		void SizeAllocated(ESize size);
+
+		ESize GetScrollCanvasSize();
+
+		void LayoutItems(Rect bound, bool force = false);
+
+		Rect GetItemBound(int index);
+
+		void ItemInserted(int index);
+
+		void ItemRemoved(int index);
+
+		void ItemUpdated(int index);
+
+		void Reset();
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemAdaptor.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemAdaptor.cs
new file mode 100644
index 00000000000..80ba7664349
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemAdaptor.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using ElmSharp;
+using ESize = ElmSharp.Size;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+
+	public abstract class ItemAdaptor : INotifyCollectionChanged
+	{
+		IList _itemsSource;
+
+		public CollectionView CollectionView { get; set; }
+
+		protected ItemAdaptor(IEnumerable items)
+		{
+			SetItemsSource(items);
+		}
+
+		public event EventHandler<SelectedItemChangedEventArgs> ItemSelected;
+
+		public virtual void SendItemSelected(int index)
+		{
+			ItemSelected?.Invoke(this, new SelectedItemChangedEventArgs(this[index], index));
+		}
+
+		public void RequestItemSelected(object item)
+		{
+			if (CollectionView != null)
+			{
+				CollectionView.SelectedItemIndex = _itemsSource.IndexOf(item);
+			}
+		}
+
+		protected void SetItemsSource(IEnumerable items)
+		{
+			switch (items)
+			{
+				case IList list:
+					_itemsSource = list;
+					_observableCollection = list as INotifyCollectionChanged;
+					break;
+				case IEnumerable<object> generic:
+					_itemsSource = new List<object>(generic);
+					break;
+				case IEnumerable _:
+					_itemsSource = new List<object>();
+					foreach (var item in items)
+					{
+						_itemsSource.Add(item);
+					}
+					break;
+			}
+		}
+
+		public object this[int index]
+		{
+			get
+			{
+				return _itemsSource[index];
+			}
+		}
+
+		public int Count => _itemsSource.Count;
+
+		INotifyCollectionChanged _observableCollection;
+		event NotifyCollectionChangedEventHandler INotifyCollectionChanged.CollectionChanged
+		{
+			add
+			{
+				if (_observableCollection != null)
+				{
+					_observableCollection.CollectionChanged += value;
+				}
+			}
+			remove
+			{
+				if (_observableCollection != null)
+				{
+					_observableCollection.CollectionChanged -= value;
+				}
+			}
+		}
+
+		public int GetItemIndex(object item)
+		{
+			return _itemsSource.IndexOf(item);
+		}
+
+		public abstract EvasObject CreateNativeView(EvasObject parent);
+
+		public abstract void RemoveNativeView(EvasObject native);
+
+		public abstract void SetBinding(EvasObject view, int index);
+
+		public abstract ESize MeasureItem(int widthConstraint, int heightConstraint);
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemTemplateAdaptor.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemTemplateAdaptor.cs
new file mode 100644
index 00000000000..46338e1360a
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ItemTemplateAdaptor.cs
@@ -0,0 +1,112 @@
+using System.Collections;
+using System.Collections.Generic;
+using ElmSharp;
+using ESize = ElmSharp.Size;
+using XLabel = Xamarin.Forms.Label;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	public class ItemDefaultTemplateAdaptor : ItemTemplateAdaptor
+	{
+		public ItemDefaultTemplateAdaptor(ItemsView itemsView) : base(itemsView)
+		{
+			ItemTemplate = new DataTemplate(() =>
+			{
+				return new StackLayout
+				{
+					BackgroundColor = Color.White,
+					Padding = 30,
+					Children =
+					{
+						new XLabel()
+					}
+				};
+			});
+		}
+		public override void SetBinding(EvasObject native, int index)
+		{
+			((GetTemplatedView(native) as StackLayout).Children[0] as XLabel).Text = this[index].ToString();
+		}
+
+		public override ESize MeasureItem(int widthConstraint, int heightConstraint)
+		{
+			var view = (View)ItemTemplate.CreateContent();
+			if (Count > 0)
+			{
+				((view as StackLayout).Children[0] as XLabel).Text = this[0].ToString();
+			}
+			var renderer = Platform.GetOrCreateRenderer(view);
+			var request = view.Measure(Forms.ConvertToScaledDP(widthConstraint), Forms.ConvertToScaledDP(heightConstraint), MeasureFlags.IncludeMargins).Request;
+			renderer.Dispose();
+			return request.ToPixel();
+		}
+	}
+
+	public class ItemTemplateAdaptor : ItemAdaptor
+	{
+		Dictionary<EvasObject, View> _nativeFormsTable = new Dictionary<EvasObject, View>();
+		ItemsView _itemsView;
+
+		public ItemTemplateAdaptor(ItemsView itemsView) : base(itemsView.ItemsSource)
+		{
+			ItemTemplate = itemsView.ItemTemplate;
+			_itemsView = itemsView;
+		}
+
+		protected ItemTemplateAdaptor(ItemsView itemsView, IEnumerable items, DataTemplate template) : base(items)
+		{
+			ItemTemplate = template;
+			_itemsView = itemsView;
+		}
+
+		protected DataTemplate ItemTemplate { get; set; }
+
+		protected View GetTemplatedView(EvasObject evasObject)
+		{
+			return _nativeFormsTable[evasObject];
+		}
+
+		public override EvasObject CreateNativeView(EvasObject parent)
+		{
+			var view = ItemTemplate.CreateContent() as View;
+			var renderer = Platform.GetOrCreateRenderer(view);
+			var native = Platform.GetOrCreateRenderer(view).NativeView;
+			view.Parent = _itemsView;
+			(renderer as LayoutRenderer)?.RegisterOnLayoutUpdated();
+
+			_nativeFormsTable[native] = view;
+			return native;
+		}
+
+		public override void RemoveNativeView(EvasObject native)
+		{
+			if (_nativeFormsTable.TryGetValue(native, out View view))
+			{
+				Platform.GetRenderer(view)?.Dispose();
+				_nativeFormsTable.Remove(native);
+			}
+		}
+
+		public override void SetBinding(EvasObject native, int index)
+		{
+			if (_nativeFormsTable.TryGetValue(native, out View view))
+			{
+				view.BindingContext = this[index];
+			}
+		}
+
+		public override ESize MeasureItem(int widthConstraint, int heightConstraint)
+		{
+			var view = ItemTemplate.CreateContent() as View;
+			var renderer = Platform.GetOrCreateRenderer(view);
+			view.Parent = _itemsView;
+			if (Count > 0)
+				view.BindingContext = this[0];
+			var request = view.Measure(Forms.ConvertToScaledDP(widthConstraint), Forms.ConvertToScaledDP(heightConstraint), MeasureFlags.IncludeMargins).Request;
+			renderer.Dispose();
+
+			return request.ToPixel();
+		}
+
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/LinearLayoutManager.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/LinearLayoutManager.cs
new file mode 100644
index 00000000000..d5c2fc4e01f
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/LinearLayoutManager.cs
@@ -0,0 +1,240 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ElmSharp;
+using ESize = ElmSharp.Size;
+
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	public class LinearLayoutManager : ICollectionViewLayoutManager
+	{
+		ESize _allocatedSize;
+		bool _isLayouting;
+		Rect _last;
+		Dictionary<int, RealizedItem> _realizedItem = new Dictionary<int, RealizedItem>();
+
+		public LinearLayoutManager(bool isHorizontal)
+		{
+			IsHorizontal = isHorizontal;
+		}
+
+		public bool IsHorizontal { get; }
+
+		public ICollectionViewController CollectionView { get; set; }
+
+		public void SizeAllocated(ESize size)
+		{
+			Reset();
+			_allocatedSize = size;
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		ESize _scrollCanvasSize;
+
+		public ESize GetScrollCanvasSize()
+		{
+			if (_scrollCanvasSize.Width > 0 && _scrollCanvasSize.Height > 0)
+				return _scrollCanvasSize;
+
+			var itemCount = CollectionView.Count;
+			var itemSize = CollectionView.GetItemSize();
+			if (IsHorizontal)
+			{
+				return _scrollCanvasSize = new ESize(itemCount * itemSize.Width, _allocatedSize.Height);
+			}
+			else
+			{
+				return _scrollCanvasSize = new ESize(_allocatedSize.Width, itemCount * itemSize.Height);
+			}
+		}
+
+		bool ShouldRearrange(Rect viewport)
+		{
+			if (_isLayouting)
+				return false;
+			if (_last.Size != viewport.Size)
+				return true;
+
+			var diff = IsHorizontal ? Math.Abs(_last.X - viewport.X) : Math.Abs(_last.Y - viewport.Y);
+			var margin = IsHorizontal ? CollectionView.GetItemSize().Width : CollectionView.GetItemSize().Height;
+			if (diff > margin)
+				return true;
+
+			return false;
+		}
+
+		public void LayoutItems(Rect bound, bool force)
+		{
+			// TODO : need to optimization. it was frequently called with similar bound value.
+			if (!ShouldRearrange(bound) && !force)
+			{
+				return;
+			}
+			_isLayouting = true;
+			_last = bound;
+
+			var size = CollectionView.GetItemSize();
+			var itemSize = IsHorizontal ? size.Width : size.Height;
+			int startIndex = Math.Max(GetStartIndex(bound, itemSize) - 2, 0);
+			int endIndex = Math.Min(GetEndIndex(bound, itemSize) + 2, CollectionView.Count - 1);
+
+			foreach (var index in _realizedItem.Keys.ToList())
+			{
+
+				if (index < startIndex || index > endIndex)
+				{
+					CollectionView.UnrealizeView(_realizedItem[index].View);
+					_realizedItem.Remove(index);
+				}
+			}
+
+			var parent = CollectionView.ParentPosition;
+			for (int i = startIndex; i <= endIndex; i++)
+			{
+				EvasObject itemView = null;
+				if (!_realizedItem.ContainsKey(i))
+				{
+					var view = CollectionView.RealizeView(i);
+					_realizedItem[i] = new RealizedItem
+					{
+						View = view,
+						Index = i,
+					};
+					itemView = view;
+				}
+				else
+				{
+					itemView = _realizedItem[i].View;
+				}
+				var itemBound = GetItemBound(i);
+				itemBound.X += parent.X;
+				itemBound.Y += parent.Y;
+				itemView.Geometry = itemBound;
+			}
+			_isLayouting = false;
+		}
+
+		public void ItemInserted(int inserted)
+		{
+			var items = _realizedItem.Keys.OrderByDescending(key => key);
+			foreach (var index in items)
+			{
+				if (index >= inserted)
+				{
+					_realizedItem[index + 1] = _realizedItem[index];
+				}
+			}
+			if (_realizedItem.ContainsKey(inserted))
+			{
+				_realizedItem.Remove(inserted);
+			}
+			else
+			{
+				var last = items.LastOrDefault();
+				if (last >= inserted)
+				{
+					_realizedItem.Remove(last);
+				}
+			}
+
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		public void ItemRemoved(int removed)
+		{
+			if (_realizedItem.ContainsKey(removed))
+			{
+				CollectionView.UnrealizeView(_realizedItem[removed].View);
+				_realizedItem.Remove(removed);
+			}
+
+			var items = _realizedItem.Keys.OrderBy(key => key);
+			foreach (var index in items)
+			{
+				if (index > removed)
+				{
+					_realizedItem[index - 1] = _realizedItem[index];
+				}
+			}
+
+			var last = items.LastOrDefault();
+			if (last > removed)
+			{
+				_realizedItem.Remove(last);
+			}
+
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		public void ItemUpdated(int index)
+		{
+			if (_realizedItem.ContainsKey(index))
+			{
+				var bound = _realizedItem[index].View.Geometry;
+				CollectionView.UnrealizeView(_realizedItem[index].View);
+				var view = CollectionView.RealizeView(index);
+				_realizedItem[index].View = view;
+				view.Geometry = bound;
+			}
+		}
+
+		public Rect GetItemBound(int index)
+		{
+			var size = CollectionView.GetItemSize();
+			if (IsHorizontal)
+			{
+				size.Height = _allocatedSize.Height;
+			}
+			else
+			{
+				size.Width = _allocatedSize.Width;
+			}
+			return
+				IsHorizontal ?
+				new Rect(index * size.Width, 0, size.Width, size.Height) :
+				new Rect(0, index * size.Height, size.Width, size.Height);
+		}
+
+		public void Reset()
+		{
+			foreach (var realizedItem in _realizedItem.Values)
+			{
+				CollectionView.UnrealizeView(realizedItem.View);
+			}
+			_realizedItem.Clear();
+			_scrollCanvasSize = new ESize(0, 0);
+		}
+
+		int GetStartIndex(Rect bound, int itemSize)
+		{
+			return ViewPortStartPoint(bound) / itemSize;
+		}
+
+		int GetEndIndex(Rect bound, int itemSize)
+		{
+			return (int)Math.Ceiling(ViewPortEndPoint(bound) / (double)itemSize);
+		}
+
+		int ViewPortStartPoint(Rect viewPort)
+		{
+			return IsHorizontal ? viewPort.X : viewPort.Y;
+		}
+
+		int ViewPortEndPoint(Rect viewPort)
+		{
+			return ViewPortStartPoint(viewPort) + ViewPortSize(viewPort);
+		}
+
+		int ViewPortSize(Rect viewPort)
+		{
+			return IsHorizontal ? viewPort.Width : viewPort.Height;
+		}
+
+		class RealizedItem
+		{
+			public ViewHolder View { get; set; }
+			public int Index { get; set; }
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/RecyclerPool.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/RecyclerPool.cs
new file mode 100644
index 00000000000..37f2e4fb512
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/RecyclerPool.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using ElmSharp;
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+	class RecyclerPool
+	{
+		LinkedList<ViewHolder> _pool = new LinkedList<ViewHolder>();
+
+		public void Clear(ItemAdaptor adaptor)
+		{
+			foreach (var item in _pool)
+			{
+				adaptor.RemoveNativeView(item);
+			}
+			_pool.Clear();
+		}
+
+		public void AddRecyclerView(ViewHolder view)
+		{
+			_pool.AddLast(view);
+		}
+
+		public ViewHolder GetRecyclerView()
+		{
+			if (_pool.First != null)
+			{
+				var fisrt = _pool.First;
+				_pool.RemoveFirst();
+				return fisrt.Value;
+			}
+			return null;
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ViewHolder.cs b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ViewHolder.cs
new file mode 100644
index 00000000000..53e68871188
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Native/CollectionView/ViewHolder.cs
@@ -0,0 +1,171 @@
+using System;
+using ElmSharp;
+using ERectangle = ElmSharp.Rectangle;
+using EColor = ElmSharp.Color;
+
+
+namespace Xamarin.Forms.Platform.Tizen.Native
+{
+
+	public enum ViewHolderState
+	{
+		Normal,
+		Selected,
+	}
+
+	public class ViewHolder : Box
+	{
+		static readonly EColor s_defaultFocusEffectColor = EColor.FromRgba(244, 244, 244, 200);
+		static readonly EColor s_defaultSelectedColor = EColor.FromRgba(227, 242, 253, 200);
+
+		ERectangle _background;
+		Button _focusArea;
+		EvasObject _content;
+		ViewHolderState _state;
+
+		public ViewHolder(EvasObject parent) : base(parent)
+		{
+			Initialize(parent);
+		}
+
+		public EColor FocusedColor { get; set; }
+		public EColor SelectedColor { get; set; }
+
+		EColor EffectiveFocusedColor => FocusedColor == EColor.Default ? s_defaultFocusEffectColor : FocusedColor;
+		EColor EffectiveSelectedColor => SelectedColor == EColor.Default ? s_defaultSelectedColor : FocusedColor;
+
+		EColor FocusSelectedColor
+		{
+			get
+			{
+				var color1 = EffectiveFocusedColor;
+				var color2 = EffectiveSelectedColor;
+				return new EColor(
+					(color1.R + color2.R) / 2,
+					(color1.G + color2.G) / 2,
+					(color1.B + color2.B) / 2,
+					(color1.A + color2.A) / 2);
+			}
+		}
+
+		public EvasObject Content
+		{
+			get
+			{
+				return _content;
+			}
+			set
+			{
+				if (_content != null)
+				{
+					UnPack(_content);
+				}
+				_content = value;
+				if (_content != null)
+				{
+					PackAfter(_content, _background);
+					_content.StackBelow(_focusArea);
+				}
+			}
+		}
+
+		public ViewHolderState State
+		{
+			get { return _state; }
+			set
+			{
+				_state = value;
+				UpdateState();
+			}
+		}
+
+		public event EventHandler Selected;
+		public event EventHandler RequestSelected;
+
+		public void ResetState()
+		{
+			State = ViewHolderState.Normal;
+			_background.Color = EColor.Transparent;
+		}
+
+		protected void SendSelected()
+		{
+			Selected?.Invoke(this, EventArgs.Empty);
+		}
+
+		protected void Initialize(EvasObject parent)
+		{
+			SetLayoutCallback(OnLayout);
+
+			_background = new ERectangle(parent)
+			{
+				Color = EColor.Transparent
+			};
+			_background.Show();
+
+			_focusArea = new Button(parent);
+			_focusArea.Color = EColor.Transparent;
+			_focusArea.BackgroundColor = EColor.Transparent;
+			_focusArea.SetPartColor("effect", EColor.Transparent);
+			_focusArea.Clicked += OnClicked;
+			_focusArea.Focused += OnFocused;
+			_focusArea.Unfocused += OnFocused;
+			_focusArea.KeyUp += OnKeyUp;
+			_focusArea.RepeatEvents = true;
+			_focusArea.Show();
+
+			PackEnd(_background);
+			PackEnd(_focusArea);
+			FocusedColor = EColor.Default;
+			Show();
+		}
+
+		protected virtual void OnFocused(object sender, EventArgs e)
+		{
+			if (_focusArea.IsFocused)
+			{
+				_background.Color = State == ViewHolderState.Selected ? FocusSelectedColor : EffectiveFocusedColor;
+			}
+			else
+			{
+				_background.Color = State == ViewHolderState.Selected ? EffectiveSelectedColor : EColor.Transparent;
+			}
+		}
+
+		protected virtual void OnClicked(object sender, EventArgs e)
+		{
+			RequestSelected?.Invoke(this, EventArgs.Empty);
+		}
+
+		protected virtual void OnLayout()
+		{
+			_background.Geometry = Geometry;
+			_focusArea.Geometry = Geometry;
+			if (_content != null)
+			{
+				_content.Geometry = Geometry;
+			}
+		}
+
+		protected virtual void UpdateState()
+		{
+			if (State == ViewHolderState.Normal)
+			{
+				_background.Color = _focusArea.IsFocused ? EffectiveFocusedColor : EColor.Transparent;
+			} else
+			{
+				_background.Color = _focusArea.IsFocused ? FocusSelectedColor : SelectedColor;
+				SendSelected();
+			}
+		}
+
+
+		void OnKeyUp(object sender, EvasKeyEventArgs e)
+		{
+			if (e.KeyName == "Enter" && _focusArea.IsFocused)
+			{
+				RequestSelected?.Invoke(this, EventArgs.Empty);
+			}
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Properties/AssemblyInfo.cs b/Xamarin.Forms.Platform.Tizen/Properties/AssemblyInfo.cs
index 9f5d2353313..8f685cc5c47 100644
--- a/Xamarin.Forms.Platform.Tizen/Properties/AssemblyInfo.cs
+++ b/Xamarin.Forms.Platform.Tizen/Properties/AssemblyInfo.cs
@@ -36,6 +36,7 @@
 [assembly: ExportRenderer(typeof(NativeViewWrapper), typeof(NativeViewWrapperRenderer))]
 [assembly: ExportRenderer(typeof(WebView), typeof(WebViewRenderer))]
 [assembly: ExportRenderer(typeof(ImageButton), typeof(ImageButtonRenderer))]
+[assembly: ExportRenderer(typeof(ItemsView), typeof(ItemsViewRenderer))]
 
 [assembly: ExportImageSourceHandler(typeof(FileImageSource), typeof(FileImageSourceHandler))]
 [assembly: ExportImageSourceHandler(typeof(StreamImageSource), typeof(StreamImageSourceHandler))]
diff --git a/Xamarin.Forms.Platform.Tizen/Renderers/ItemsViewRenderer.cs b/Xamarin.Forms.Platform.Tizen/Renderers/ItemsViewRenderer.cs
new file mode 100644
index 00000000000..01e8ec74e71
--- /dev/null
+++ b/Xamarin.Forms.Platform.Tizen/Renderers/ItemsViewRenderer.cs
@@ -0,0 +1,182 @@
+using System.Collections.Specialized;
+using System.Linq;
+
+using Xamarin.Forms.Platform.Tizen.Native;
+
+namespace Xamarin.Forms.Platform.Tizen
+{
+	public class ItemsViewRenderer : ViewRenderer<ItemsView, Native.CollectionView>
+	{
+		INotifyCollectionChanged _observableSource;
+
+		public ItemsViewRenderer()
+		{
+			RegisterPropertyHandler(ItemsView.ItemsSourceProperty, UpdateItemsSource);
+			RegisterPropertyHandler(ItemsView.ItemTemplateProperty, UpdateAdaptor);
+			RegisterPropertyHandler(ItemsView.ItemsLayoutProperty, UpdateItemsLayout);
+			RegisterPropertyHandler(SelectableItemsView.SelectedItemProperty, UpdateSelectedItem);
+			RegisterPropertyHandler(SelectableItemsView.SelectionModeProperty, UpdateSelectionMode);
+		}
+
+		protected override void OnElementChanged(ElementChangedEventArgs<ItemsView> e)
+		{
+			if (Control == null)
+			{
+				SetNativeControl(new Native.CollectionView(Forms.NativeParent));
+			}
+
+			if (e.NewElement != null)
+			{
+				e.NewElement.ScrollToRequested += OnScrollToRequest;
+			}
+
+			base.OnElementChanged(e);
+			UpdateAdaptor(false);
+		}
+
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing)
+			{
+				if (Element != null)
+				{
+					Element.ScrollToRequested -= OnScrollToRequest;
+					Element.ItemsLayout.PropertyChanged -= OnLayoutPropertyChanged;
+				}
+				if (_observableSource != null)
+				{
+					_observableSource.CollectionChanged -= OnCollectionChanged;
+				}
+			}
+			base.Dispose(disposing);
+		}
+
+		void UpdateSelectedItem(bool initialize)
+		{
+			if (initialize)
+				return;
+
+			if (Element is SelectableItemsView selectable)
+			{
+				Control?.Adaptor?.RequestItemSelected(selectable.SelectedItem);
+			}
+		}
+
+		void UpdateSelectionMode()
+		{
+			if (Element is SelectableItemsView selectable)
+			{
+				Control.SelectionMode = selectable.SelectionMode == SelectionMode.None ? CollectionViewSelectionMode.None : CollectionViewSelectionMode.Single;
+			}
+		}
+
+		void OnScrollToRequest(object sender, ScrollToRequestEventArgs e)
+		{
+			if (e.Mode == ScrollToMode.Position)
+			{
+				Control.ScrollTo(e.Index, e.ScrollToPosition, e.IsAnimated);
+			}
+			else
+			{
+				Control.ScrollTo(e.Item, e.ScrollToPosition, e.IsAnimated);
+			}
+		}
+
+		void UpdateItemsSource(bool initialize)
+		{
+			if (Element.ItemsSource is INotifyCollectionChanged collectionChanged)
+			{
+				if (_observableSource != null)
+				{
+					_observableSource.CollectionChanged -= OnCollectionChanged;
+				}
+				_observableSource = collectionChanged;
+				_observableSource.CollectionChanged += OnCollectionChanged;
+			}
+			UpdateAdaptor(initialize);
+		}
+
+		void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+		{
+			if (Element.ItemsSource == null || !Element.ItemsSource.Cast<object>().Any())
+			{
+				Control.Adaptor = EmptyItemAdaptor.Create(Element);
+			}
+			else
+			{
+				if (Control.Adaptor is EmptyItemAdaptor)
+				{
+					UpdateAdaptor(false);
+				}
+			}
+		}
+
+		void UpdateAdaptor(bool initialize)
+		{
+			if (!initialize)
+			{
+				if (Element.ItemsSource == null || !Element.ItemsSource.Cast<object>().Any())
+				{
+					Control.Adaptor = EmptyItemAdaptor.Create(Element);
+				}
+				else if (Element.ItemTemplate == null)
+				{
+					Control.Adaptor = new ItemDefaultTemplateAdaptor(Element);
+				}
+				else
+				{
+					Control.Adaptor = new ItemTemplateAdaptor(Element);
+					Control.Adaptor.ItemSelected += OnItemSelectedFromUI;
+				}
+			}
+		}
+
+		void OnItemSelectedFromUI(object sender, SelectedItemChangedEventArgs e)
+		{
+			if (Element is SelectableItemsView selectableItemsView)
+			{
+				selectableItemsView.SelectedItem = e.SelectedItem;
+			}
+		}
+
+		void UpdateItemsLayout()
+		{
+			if (Element.ItemsLayout != null)
+			{
+				Control.LayoutManager = Element.ItemsLayout.ToLayoutManager();
+				Control.SnapPointsType = (Element.ItemsLayout as ItemsLayout)?.SnapPointsType ?? SnapPointsType.None;
+				Element.ItemsLayout.PropertyChanged += OnLayoutPropertyChanged;
+			}
+		}
+
+		void OnLayoutPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName == nameof(ItemsLayout.SnapPointsType))
+			{
+				Control.SnapPointsType = (Element.ItemsLayout as ItemsLayout)?.SnapPointsType ?? SnapPointsType.None;
+			}
+			else if (e.PropertyName == nameof(GridItemsLayout.Span))
+			{
+				((GridLayoutManager)(Control.LayoutManager)).UpdateSpan(((GridItemsLayout)Element.ItemsLayout).Span);
+			}
+		}
+	}
+
+	static class ItemsLayoutExtension
+	{
+		public static ICollectionViewLayoutManager ToLayoutManager(this IItemsLayout layout)
+		{
+			switch (layout)
+			{
+				case ListItemsLayout listItemsLayout:
+					return new LinearLayoutManager(listItemsLayout.Orientation == ItemsLayoutOrientation.Horizontal);
+				case GridItemsLayout gridItemsLayout:
+					return new GridLayoutManager(gridItemsLayout.Orientation == ItemsLayoutOrientation.Horizontal, gridItemsLayout.Span);
+				default:
+					break;
+			}
+
+			return new LinearLayoutManager(false);
+		}
+	}
+}
diff --git a/Xamarin.Forms.Platform.Tizen/Renderers/VisualElementRenderer.cs b/Xamarin.Forms.Platform.Tizen/Renderers/VisualElementRenderer.cs
index bc3bf74d9a6..286b728d091 100644
--- a/Xamarin.Forms.Platform.Tizen/Renderers/VisualElementRenderer.cs
+++ b/Xamarin.Forms.Platform.Tizen/Renderers/VisualElementRenderer.cs
@@ -598,12 +598,12 @@ public virtual ERect GetNativeContentGeometry()
 
 		static double ComputeAbsoluteX(VisualElement e)
 		{
-			return e.X + ((e.RealParent is VisualElement) && !(e.RealParent is ListView) ? Forms.ConvertToScaledDP(Platform.GetRenderer(e.RealParent).GetNativeContentGeometry().X) : 0.0);
+			return e.X + ((e.RealParent is VisualElement) && !(e.RealParent is ListView || e.RealParent is ItemsView) ? Forms.ConvertToScaledDP(Platform.GetRenderer(e.RealParent).GetNativeContentGeometry().X) : 0.0);
 		}
 
 		static double ComputeAbsoluteY(VisualElement e)
 		{
-			return e.Y + ((e.RealParent is VisualElement) && !(e.RealParent is ListView) ? Forms.ConvertToScaledDP(Platform.GetRenderer(e.RealParent).GetNativeContentGeometry().Y) : 0.0);
+			return e.Y + ((e.RealParent is VisualElement) && !(e.RealParent is ListView || e.RealParent is ItemsView) ? Forms.ConvertToScaledDP(Platform.GetRenderer(e.RealParent).GetNativeContentGeometry().Y) : 0.0);
 		}
 
 		static Point ComputeAbsolutePoint(VisualElement e)

From 68652b9f10416d5fc8a58f07a04cd5eb740e3415 Mon Sep 17 00:00:00 2001
From: Andrei Nitescu <nitescua@yahoo.com>
Date: Thu, 14 Mar 2019 13:18:00 +0200
Subject: [PATCH 14/25] iOS: Color of Editor Placeholder is different than
 Entry (#5259) fixes #5252

---
 .../Issue5252.cs                              | 49 +++++++++++++++++++
 ...rin.Forms.Controls.Issues.Shared.projitems |  1 +
 .../Renderers/EditorRenderer.cs               | 10 ++--
 3 files changed, 57 insertions(+), 3 deletions(-)
 create mode 100644 Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5252.cs

diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5252.cs b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5252.cs
new file mode 100644
index 00000000000..0db2a2f50fd
--- /dev/null
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Issue5252.cs
@@ -0,0 +1,49 @@
+using System.Linq;
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.Forms.Internals;
+
+namespace Xamarin.Forms.Controls.Issues
+{
+	[Preserve(AllMembers = true)]
+	[Issue(IssueTracker.Github, 5252, "iOS: The Editor and Entry placeholder default color should be the same", PlatformAffected.iOS)]
+
+	class Issue5252 : TestContentPage
+	{
+		protected override void Init()
+		{
+			var sl = new StackLayout();
+			sl.Children.Add(new Label()
+			{
+				Text = "iOS: The Editor and Entry placeholder default color should be the same for consistency"
+			});
+
+			var entry = new Entry()
+			{
+				Placeholder = "Entry placeholder",
+			};
+			sl.Children.Add(entry);
+
+			var editor = new Editor()
+			{
+				Placeholder = "Editor placeholder",
+			};
+			sl.Children.Add(editor);
+
+			sl.Children.Add(new Button()
+			{
+				Text = "Toggle placeholder color",
+				Command = new Command(() =>
+				{
+					entry.PlaceholderColor = entry.PlaceholderColor.IsDefault ? Color.Red : (Color)Entry.PlaceholderColorProperty.DefaultValue;
+					editor.PlaceholderColor = editor.PlaceholderColor.IsDefault ? Color.Red : (Color)Editor.PlaceholderColorProperty.DefaultValue;
+				})
+			});
+
+
+			Content = new ScrollView()
+			{
+				Content = sl
+			};
+		}
+	}
+}
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
index 5d47b229adc..667b86a2a24 100644
--- a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
@@ -430,6 +430,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="$(MSBuildThisFileDirectory)Issue4600.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Issue5252.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue5057.xaml.cs">
       <DependentUpon>Issue5057.xaml</DependentUpon>
       <SubType>Code</SubType>
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
index e14d888671b..de56672cdd9 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
@@ -9,6 +9,9 @@ namespace Xamarin.Forms.Platform.iOS
 {
 	public class EditorRenderer : EditorRendererBase<UITextView>
 	{
+		// Using same placeholder color as for the Entry
+		readonly UIColor _defaultPlaceholderColor = ColorExtensions.SeventyPercentGrey;
+
 		UILabel _placeholderLabel;
 
 		public EditorRenderer()
@@ -63,10 +66,11 @@ protected internal override void UpdatePlaceholderText()
 
 		protected internal override void UpdatePlaceholderColor()
 		{
-			if (Element.PlaceholderColor == Color.Default)
-				_placeholderLabel.TextColor = UIColor.DarkGray;
+			Color placeholderColor = Element.PlaceholderColor;
+			if (placeholderColor.IsDefault)
+				_placeholderLabel.TextColor = _defaultPlaceholderColor;
 			else
-				_placeholderLabel.TextColor = Element.PlaceholderColor.ToUIColor();
+				_placeholderLabel.TextColor = placeholderColor.ToUIColor();
 		}
 
 		void CreatePlaceholderLabel()

From 12f5b702ef4c8bcbd343b6272555ba9f01b36438 Mon Sep 17 00:00:00 2001
From: Akihiko Odaki <akihiko.odaki.4i@stu.hosei.ac.jp>
Date: Thu, 14 Mar 2019 21:39:29 +0900
Subject: [PATCH 15/25] [XamlC] Correctly load addresses of values in compiled
 binding paths (#5082)

---
 .../SetPropertiesVisitor.cs                   | 25 +++++++++++++++++--
 .../BindingsCompiler.xaml                     |  1 +
 .../BindingsCompiler.xaml.cs                  | 13 ++++++++++
 3 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs b/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
index 5d6194adb90..0d455f69477 100644
--- a/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
+++ b/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
@@ -527,6 +527,8 @@ static IEnumerable<Instruction> CompiledBindingGetGetter(TypeReference tSourceRe
 				il.Emit(Ret);
 			}
 			else {
+				var locs = new Dictionary<TypeReference, VariableDefinition>();
+
 				if (tSourceRef.IsValueType)
 					il.Emit(Ldarga_S, (byte)0);
 				else
@@ -535,6 +537,19 @@ static IEnumerable<Instruction> CompiledBindingGetGetter(TypeReference tSourceRe
 				for (int i = 0; i < properties.Count; i++) {
 					(PropertyDefinition property, TypeReference propDeclTypeRef, string indexArg) = properties[i];
 
+					if (i > 0 && propDeclTypeRef.IsValueType) {
+						var importedPropDeclTypeRef = module.ImportReference(propDeclTypeRef);
+
+						if (!locs.TryGetValue(importedPropDeclTypeRef, out var loc)) {
+							loc = new VariableDefinition(importedPropDeclTypeRef);
+							getter.Body.Variables.Add(loc);
+							locs[importedPropDeclTypeRef] = loc;
+						}
+
+						il.Emit(Stloc, loc);
+						il.Emit(Ldloca, loc);
+					}
+
 					if (!property.PropertyType.IsValueType) { //if part of the path is null, return (default(T), false)
 						var nop = Create(Nop);
 						il.Emit(Dup);
@@ -543,8 +558,14 @@ static IEnumerable<Instruction> CompiledBindingGetGetter(TypeReference tSourceRe
 						il.Emit(Brfalse, nop);
 						il.Emit(Pop);
 						if (tPropertyRef.IsValueType) {
-							var defaultValueVarDef = new VariableDefinition(tPropertyRef);
-							getter.Body.Variables.Add(defaultValueVarDef);
+							var importedTPropertyRef = module.ImportReference(tPropertyRef);
+
+							if (!locs.TryGetValue(importedTPropertyRef, out var defaultValueVarDef)) {
+								defaultValueVarDef = new VariableDefinition(tPropertyRef);
+								getter.Body.Variables.Add(defaultValueVarDef);
+								locs[importedTPropertyRef] = defaultValueVarDef;
+							}
+
 							il.Emit(Ldloca_S, defaultValueVarDef);
 							il.Emit(Initobj, tPropertyRef);
 							il.Emit(Ldloc, defaultValueVarDef);
diff --git a/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml b/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml
index 59a15f3f6d2..fda4a6707f3 100644
--- a/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml
+++ b/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml
@@ -18,6 +18,7 @@
 			<Entry Text="{Binding Text, Mode=TwoWay}" x:Name="entry0"/>
             <Label Text="{Binding .}" x:Name="label7" x:DataType="sys:Int32"/>
             <Label Text="{Binding Text, Mode=OneTime}" x:Name="label8" />
+			<Label Text="{Binding StructModel.Text}" x:Name="label9" />
 		</StackLayout>
 		<Label Text="{Binding Text}" x:Name="labelWithUncompiledBinding" />
 	</StackLayout>
diff --git a/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml.cs b/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml.cs
index b5f72f8c372..e9967b93921 100644
--- a/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml.cs
+++ b/Xamarin.Forms.Xaml.UnitTests/BindingsCompiler.xaml.cs
@@ -49,6 +49,9 @@ public void Test(bool useCompiledXaml)
 					Model = new MockViewModel {
 						Text = "Text1"
 					},
+					StructModel = new MockStructViewModel {
+						Text = "Text9"
+					}
 				};
 				vm.Model [3] = "TextIndex";
 
@@ -70,6 +73,7 @@ public void Test(bool useCompiledXaml)
 				//value types
 				Assert.That(layout.label5.Text, Is.EqualTo("42"));
 				Assert.That(layout.label6.Text, Is.EqualTo("text6"));
+				Assert.AreEqual("Text9", layout.label9.Text);
 
 				//testing selfPath
 				layout.label4.BindingContext = "Self";
@@ -145,6 +149,15 @@ public MockViewModel Model {
 			}
 		}
 
+		MockStructViewModel _structModel;
+		public MockStructViewModel StructModel {
+			get { return _structModel; }
+			set {
+				_structModel = value;
+				OnPropertyChanged();
+			}
+		}
+
 		string [] values = new string [5];
 		[IndexerName("Indexer")]
 		public string this [int v] {

From 6ed70b00bdcac7220fc6ad4a9dba338485c7dcce Mon Sep 17 00:00:00 2001
From: Rui Marinho <me@ruimarinho.net>
Date: Thu, 14 Mar 2019 15:31:44 +0000
Subject: [PATCH 16/25] =?UTF-8?q?[Controls]=C2=A0Only=20register=20AppComp?=
 =?UTF-8?q?act=20renderer=20if=20running=20in=20that=20context?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../_50787CustomRenderer.cs                                 | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Xamarin.Forms.ControlGallery.Android/_50787CustomRenderer.cs b/Xamarin.Forms.ControlGallery.Android/_50787CustomRenderer.cs
index 12fd78dfd0d..3cc4a12d820 100644
--- a/Xamarin.Forms.ControlGallery.Android/_50787CustomRenderer.cs
+++ b/Xamarin.Forms.ControlGallery.Android/_50787CustomRenderer.cs
@@ -1,4 +1,5 @@
-using Android.Content;
+#if !FORMS_APPLICATION_ACTIVITY && !PRE_APPLICATION_CLASS
+using Android.Content;
 using Xamarin.Forms;
 using Xamarin.Forms.ControlGallery.Android;
 using Xamarin.Forms.Platform.Android.AppCompat;
@@ -24,4 +25,5 @@ protected override void SetupPageTransition(FragmentTransaction transaction, boo
 				transaction.SetCustomAnimations(Resource.Animation.enter_from_left, Resource.Animation.exit_to_right);
 		}
 	}
-}
\ No newline at end of file
+}
+#endif
\ No newline at end of file

From f091a9576d0140ccf2b2d7635cd58b58da760e95 Mon Sep 17 00:00:00 2001
From: Brandon Minnick <13558917+brminnick@users.noreply.github.com>
Date: Thu, 14 Mar 2019 17:30:19 -0700
Subject: [PATCH 17/25] Added AppLinks (#5568)

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index e561ca11e73..aa6f15a3957 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ Platform/Feature               | Package name                              | Sta
 Core             | `Xamarin.Forms` | [![NuGet](https://img.shields.io/nuget/v/Xamarin.Forms.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Xamarin.Forms/)| [![MyGet](https://img.shields.io/myget/xamarinforms-ci/vpre/Xamarin.Forms.svg?style=flat-square&label=myget)](https://myget.org/feed/xamarinforms-ci/package/nuget/Xamarin.Forms)
 Maps                 | `Xamarin.Forms.Maps`    | [![NuGet](https://img.shields.io/nuget/v/Xamarin.Forms.Maps.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Xamarin.Forms.Maps/) | [![MyGet](https://img.shields.io/myget/xamarinforms-ci/vpre/Xamarin.Forms.Maps.svg?style=flat-square&label=myget)](https://myget.org/feed/xamarinforms-ci/package/nuget/Xamarin.Forms.Maps)
 Pages  | `Xamarin.Forms.Pages`  | [![NuGet](https://img.shields.io/nuget/v/Xamarin.Forms.Pages.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Xamarin.Forms.Pages/) | [![MyGet](https://img.shields.io/myget/xamarinforms-ci/vpre/Xamarin.Forms.Pages.svg?style=flat-square&label=myget)](https://myget.org/feed/xamarin.forms-ci/package/nuget/Xamarin.Forms.Pages)
+AppLinks  | `Xamarin.Forms.AppLinks`  | [![NuGet](https://img.shields.io/nuget/v/Xamarin.Forms.AppLinks.svg?style=flat-square&label=nuget)](https://www.nuget.org/packages/Xamarin.Forms.AppLinks/) | [![MyGet](https://img.shields.io/myget/xamarinforms-ci/vpre/Xamarin.Forms.AppLinks.svg?style=flat-square&label=myget)](https://myget.org/feed/xamarin.forms-ci/package/nuget/Xamarin.Forms.AppLinks)
 
 If you want to use the latest dev build then you should read [this blog post](https://blog.xamarin.com/try-the-latest-in-xamarin-forms-with-nightly-builds):
 

From 5c07fa9b43f119f457c4d9dd0653d98591c616d2 Mon Sep 17 00:00:00 2001
From: Stephane Delcroix <stephane@delcroix.org>
Date: Fri, 15 Mar 2019 01:42:54 +0100
Subject: [PATCH 18/25] [X] resilient to unyped x:Name (#5552)

Allow the previewer to recover from an x:Name attribute on a element
with unresolved type.

- fixes #5546
- closes #5547
---
 .../DesignTimeLoaderTests.cs                  | 19 ++++++++++++++
 Xamarin.Forms.Xaml/RegisterXNamesVisitor.cs   | 25 +++++++++++++------
 2 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs b/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
index 0023d0ac8b2..5af2009dd9e 100644
--- a/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
+++ b/Xamarin.Forms.Xaml.UnitTests/DesignTimeLoaderTests.cs
@@ -627,6 +627,25 @@ public void CanResolveRootNodeWithoutAssembly()
 			Assert.That(clrNamespace, Is.EqualTo("my.namespace"));
 			Assert.That(typeName, Is.EqualTo("MissingType"));
 		}
+
+		[Test]
+		public void IgnoreNamedMissingTypeException()
+		{
+			var xaml = @"
+					<ContentPage xmlns=""http://xamarin.com/schemas/2014/forms""
+						xmlns:x=""http://schemas.microsoft.com/winfx/2009/xaml""
+						xmlns:local=""clr-namespace:Xamarin.Forms.Xaml.UnitTests;assembly=Xamarin.Forms.Xaml.UnitTests"">
+						<StackLayout>
+							<local:Missing x:Name=""MyName"" />
+							<Button x:Name=""button"" />
+							<Button x:Name=""button"" />
+						</StackLayout>
+					</ContentPage>";
+			var exceptions = new List<Exception>();
+			Xamarin.Forms.Internals.ResourceLoader.ExceptionHandler = exceptions.Add;
+			Assert.DoesNotThrow(() => XamlLoader.Create(xaml, true));
+			Assert.That(exceptions.Count, Is.GreaterThan(1));
+		}
 	}
 
 	public class InstantiateThrows
diff --git a/Xamarin.Forms.Xaml/RegisterXNamesVisitor.cs b/Xamarin.Forms.Xaml/RegisterXNamesVisitor.cs
index b84747ca285..7d70da589f0 100644
--- a/Xamarin.Forms.Xaml/RegisterXNamesVisitor.cs
+++ b/Xamarin.Forms.Xaml/RegisterXNamesVisitor.cs
@@ -30,18 +30,29 @@ public void Visit(ValueNode node, INode parentNode)
 		{
 			if (!IsXNameProperty(node, parentNode))
 				return;
-			try
-			{
+
+			try {
 				((IElementNode)parentNode).Namescope.RegisterName((string)node.Value, Values[parentNode]);
 			}
-			catch (ArgumentException ae)
-			{
+			catch (ArgumentException ae) {
 				if (ae.ParamName != "name")
 					throw ae;
-				throw new XamlParseException($"An element with the name \"{(string)node.Value}\" already exists in this NameScope", node);
+				var xpe = new XamlParseException($"An element with the name \"{(string)node.Value}\" already exists in this NameScope", node);
+				if (Context.ExceptionHandler != null) {
+					Context.ExceptionHandler(xpe);
+					return;
+				}
+				throw xpe;
+			}
+			catch (KeyNotFoundException knfe) {
+				if (Context.ExceptionHandler != null) {
+					Context.ExceptionHandler(knfe);
+					return;
+				}
+				throw knfe;
 			}
-			var element = Values[parentNode] as Element;
-			if (element != null)
+
+			if (Values[parentNode] is Element element)
 				element.StyleId = element.StyleId ?? (string)node.Value;
 		}
 

From c5f95cc35374682b9969a4226d3f9cc2bb16b698 Mon Sep 17 00:00:00 2001
From: "E.Z. Hart" <hartez@users.noreply.github.com>
Date: Fri, 15 Mar 2019 05:32:17 -0600
Subject: [PATCH 19/25] [iOS] Fix crash when going from empty to having items
 (#5430)

* Fix crash on iOS when going from empty to having items

* Temporarily patching EditorRenderer so iOS tests can run
---
 .../EmptyViewLoadSimulateGallery.xaml.cs      |  5 +-
 .../ExampleTemplates.cs                       |  3 +-
 .../Tests/CollectionViewUITests.cs            | 13 ++++-
 .../CollectionView/ItemsViewController.cs     | 56 ++++++++++++++++++-
 .../Renderers/EditorRenderer.cs               |  2 +-
 5 files changed, 74 insertions(+), 5 deletions(-)

diff --git a/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/EmptyViewGalleries/EmptyViewLoadSimulateGallery.xaml.cs b/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/EmptyViewGalleries/EmptyViewLoadSimulateGallery.xaml.cs
index 066abd6c457..839cc8c7d99 100644
--- a/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/EmptyViewGalleries/EmptyViewLoadSimulateGallery.xaml.cs
+++ b/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/EmptyViewGalleries/EmptyViewLoadSimulateGallery.xaml.cs
@@ -1,4 +1,5 @@
-using System.Threading;
+using System.Collections.Generic;
+using System.Threading;
 using Xamarin.Forms.Xaml;
 
 namespace Xamarin.Forms.Controls.GalleryPages.CollectionViewGalleries.EmptyViewGalleries
@@ -16,6 +17,8 @@ public EmptyViewLoadSimulateGallery()
 
 			new Thread(() =>
 			{
+				Thread.Sleep(1000);
+				Device.BeginInvokeOnMainThread(() => CollectionView.ItemsSource = new List<object>());
 				Thread.Sleep(1000);
 				Device.BeginInvokeOnMainThread(() => CollectionView.ItemsSource = _demoFilteredItemSource.Items);
 			}).Start();
diff --git a/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/ExampleTemplates.cs b/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/ExampleTemplates.cs
index e884f5cab4d..6707c68bd94 100644
--- a/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/ExampleTemplates.cs
+++ b/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/ExampleTemplates.cs
@@ -20,7 +20,8 @@ public static DataTemplate PhotoTemplate()
 				{
 					HeightRequest = 100, WidthRequest = 100,
 					HorizontalOptions = LayoutOptions.Center,
-					VerticalOptions = LayoutOptions.Center
+					VerticalOptions = LayoutOptions.Center,
+					AutomationId = "photo"
 				};
 
 				image.SetBinding(Image.SourceProperty, new Binding("Image"));
diff --git a/Xamarin.Forms.Core.UITests.Shared/Tests/CollectionViewUITests.cs b/Xamarin.Forms.Core.UITests.Shared/Tests/CollectionViewUITests.cs
index 31df17e2b0e..2edb46c5897 100644
--- a/Xamarin.Forms.Core.UITests.Shared/Tests/CollectionViewUITests.cs
+++ b/Xamarin.Forms.Core.UITests.Shared/Tests/CollectionViewUITests.cs
@@ -279,5 +279,16 @@ void TesItemsPosition(string gallery)
 				}
 			}
 		}
-	}
+
+        [TestCase("EmptyView", "EmptyView (load simulation)", "photo")]
+        public void VisitAndCheckItem(string collectionTestName, string subgallery, string item)
+        {
+            VisitInitialGallery(collectionTestName);
+
+            App.WaitForElement(t => t.Marked(subgallery));
+            App.Tap(t => t.Marked(subgallery));
+
+            App.WaitForElement(t => t.Marked(item));
+        }
+    }
 }
\ No newline at end of file
diff --git a/Xamarin.Forms.Platform.iOS/CollectionView/ItemsViewController.cs b/Xamarin.Forms.Platform.iOS/CollectionView/ItemsViewController.cs
index 8b52736d559..7b9b502678f 100644
--- a/Xamarin.Forms.Platform.iOS/CollectionView/ItemsViewController.cs
+++ b/Xamarin.Forms.Platform.iOS/CollectionView/ItemsViewController.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Foundation;
 using UIKit;
 
@@ -12,6 +13,7 @@ public class ItemsViewController : UICollectionViewController
 		readonly ItemsView _itemsView;
 		ItemsViewLayout _layout;
 		bool _initialConstraintsSet;
+		bool _safeForReload;
 		bool _wasEmpty;
 		bool _currentBackgroundIsEmptyView;
 
@@ -25,6 +27,10 @@ public ItemsViewController(ItemsView itemsView, ItemsViewLayout layout) : base(l
 		{
 			_itemsView = itemsView;
 			_itemsSource = ItemsSourceFactory.Create(_itemsView.ItemsSource, CollectionView);
+			
+			// If we already have data, the UICollectionView will have items and we'll be safe to call
+			// ReloadData if the ItemsSource changes in the future (see UpdateItemsSource for more).
+			_safeForReload = _itemsSource?.Count > 0;
 
 			UpdateLayout(layout);
 		}
@@ -113,11 +119,59 @@ public override void ViewWillLayoutSubviews()
 
 		public virtual void UpdateItemsSource()
 		{
-			_itemsSource =  ItemsSourceFactory.Create(_itemsView.ItemsSource, CollectionView);
+			if (_safeForReload)
+			{
+				UpdateItemsSourceAndReload();
+			}
+			else
+			{
+				// Okay, thus far this UICollectionView has never had any items in it. At this point, if
+				// we set the ItemsSource and try to call ReloadData(), it'll crash. AFAICT this is a bug, but
+				// until it's fixed (or we can figure out another way to go from empty -> having items), we'll
+				// have to use this crazy workaround
+				EmptyCollectionViewReloadWorkaround();
+			}
+		}
+
+		void UpdateItemsSourceAndReload()
+		{
+			_itemsSource = ItemsSourceFactory.Create(_itemsView.ItemsSource, CollectionView);
 			CollectionView.ReloadData();
 			CollectionView.CollectionViewLayout.InvalidateLayout();
 		}
 
+		void EmptyCollectionViewReloadWorkaround()
+		{
+			var enumerator = _itemsView.ItemsSource.GetEnumerator();
+
+			if (!enumerator.MoveNext())
+			{
+				// The source we're updating to is empty, so we can just update as normal; it won't crash
+				UpdateItemsSourceAndReload();
+			}
+			else
+			{
+				// Grab the first item from the new ItemsSource and create a usable source for the UICollectionView
+				// from that
+				var firstItem = new List<object> { enumerator.Current };
+				_itemsSource = ItemsSourceFactory.Create(firstItem, CollectionView);
+
+				// Insert that item into the UICollectionView
+				// TODO ezhart When we implement grouping, this will need to be the index of the first actual item
+				// Which might not be zero,zero if we have empty groups
+				var indexesToInsert = new NSIndexPath[1] { NSIndexPath.Create(0, 0) };
+
+				UIView.PerformWithoutAnimation(() =>
+				{
+					CollectionView.InsertItems(indexesToInsert);
+				});
+
+				// Okay, from now on we can just call ReloadData and things will work fine
+				_safeForReload = true;
+				UpdateItemsSource();
+			}
+		}
+
 		protected virtual void UpdateDefaultCell(DefaultCell cell, NSIndexPath indexPath)
 		{
 			cell.Label.Text = _itemsSource[indexPath.Row].ToString();
diff --git a/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs b/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
index e14d888671b..5433328b3c3 100644
--- a/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Renderers/EditorRenderer.cs
@@ -60,7 +60,7 @@ protected internal override void UpdatePlaceholderText()
 		{
 			_placeholderLabel.Text = Element.Placeholder;
 		}
-
+		
 		protected internal override void UpdatePlaceholderColor()
 		{
 			if (Element.PlaceholderColor == Color.Default)

From 0376a5f6928f3bba7ecc160f6079531d12166ae0 Mon Sep 17 00:00:00 2001
From: Shane Neuville <shane94@hotmail.com>
Date: Fri, 15 Mar 2019 15:43:04 -0600
Subject: [PATCH 20/25] [Android] fix focus event on android and add UI Tests
 (#5528)

* fix focus event for material entry and add ui tests

* fix iOS

* - Focused
fixes #5509
---
 Xamarin.Forms.Controls/CoreGallery.cs         | 14 ++++++-
 .../CoreGalleryPages/CoreGalleryPage.cs       | 13 +++++++
 .../ViewContainers/StateViewContainer.cs      |  7 +++-
 .../Tests/EntryUITests.cs                     | 18 ++++++++-
 .../Tests/MaterialEntryUITests.cs             | 27 ++++++++++++++
 .../Utilities/AppExtensions.cs                | 37 ++++++++++++++-----
 .../Xamarin.Forms.Core.UITests.projitems      |  1 +
 .../MaterialFormsTextInputLayoutBase.cs       | 11 +++++-
 .../Cells/TextCellRenderer.cs                 |  9 +++++
 .../ViewRenderer.cs                           |  2 +
 Xamarin.Forms.Platform.UAP/Resources.xaml     |  2 +-
 .../Cells/TextCellRenderer.cs                 |  7 ++++
 12 files changed, 130 insertions(+), 18 deletions(-)
 create mode 100644 Xamarin.Forms.Core.UITests.Shared/Tests/MaterialEntryUITests.cs

diff --git a/Xamarin.Forms.Controls/CoreGallery.cs b/Xamarin.Forms.Controls/CoreGallery.cs
index df9bab3d624..3ef12da8a33 100644
--- a/Xamarin.Forms.Controls/CoreGallery.cs
+++ b/Xamarin.Forms.Controls/CoreGallery.cs
@@ -246,6 +246,7 @@ public CoreRootView()
 	[Preserve(AllMembers = true)]
 	internal class CorePageView : ListView
 	{
+		[Preserve(AllMembers = true)]
 		internal class GalleryPageFactory
 		{
 			public GalleryPageFactory(Func<Page> create, string title)
@@ -258,11 +259,18 @@ public GalleryPageFactory(Func<Page> create, string title)
 				};
 
 				Title = title;
+				TitleAutomationId = $"{Title}AutomationId";
 			}
 
 			public Func<Page> Realize { get; set; }
 			public string Title { get; set; }
 
+			public string TitleAutomationId
+			{
+				get;
+				set;
+			}
+
 			public override string ToString()
 			{
 				// a11y: let Narrator read a friendly string instead of the default ToString()
@@ -287,7 +295,6 @@ public override string ToString()
 				new GalleryPageFactory(() => new CellForceUpdateSizeGalleryPage(), "Cell Force Update Size Gallery"),
 				new GalleryPageFactory(() => new AppearingGalleryPage(), "Appearing Gallery"),
 				new GalleryPageFactory(() => new EntryCoreGalleryPage(), "Entry Gallery"),
-				new GalleryPageFactory(() => new EntryCoreGalleryPage{ Visual = VisualMarker.Material }, "Entry Gallery (Material)"),
 				new GalleryPageFactory(() => new MaterialEntryGalleryPage(), "Entry Material Demos"),
 				new GalleryPageFactory(() => new NavBarTitleTestPage(), "Titles And Navbar Windows"),
 				new GalleryPageFactory(() => new PanGestureGalleryPage(), "Pan gesture Gallery"),
@@ -389,7 +396,7 @@ public override string ToString()
 				new GalleryPageFactory(() => new TableViewGallery(), "TableView Gallery - Legacy"),
 				new GalleryPageFactory(() => new TemplatedCarouselGallery(), "TemplatedCarouselPage Gallery - Legacy"),
 				new GalleryPageFactory(() => new TemplatedTabbedGallery(), "TemplatedTabbedPage Gallery - Legacy"),
-				 new GalleryPageFactory(() => new UnevenViewCellGallery(), "UnevenViewCell Gallery - Legacy"),
+				new GalleryPageFactory(() => new UnevenViewCellGallery(), "UnevenViewCell Gallery - Legacy"),
 				new GalleryPageFactory(() => new UnevenListGallery(), "UnevenList Gallery - Legacy"),
 				new GalleryPageFactory(() => new ViewCellGallery(), "ViewCell Gallery - Legacy"),
 				new GalleryPageFactory(() => new WebViewGallery(), "WebView Gallery - Legacy"),
@@ -428,9 +435,12 @@ public CorePageView(Page rootPage, NavigationBehavior navigationBehavior = Navig
 						}
 					})
 				});
+
 				return cell;
 			});
+
 			template.SetBinding(TextCell.TextProperty, "Title");
+			template.SetBinding(TextCell.AutomationIdProperty, "TitleAutomationId");
 
 			BindingContext = _pages;
 			ItemTemplate = template;
diff --git a/Xamarin.Forms.Controls/CoreGalleryPages/CoreGalleryPage.cs b/Xamarin.Forms.Controls/CoreGalleryPages/CoreGalleryPage.cs
index ead8b6f48af..03584bdcdf7 100644
--- a/Xamarin.Forms.Controls/CoreGalleryPages/CoreGalleryPage.cs
+++ b/Xamarin.Forms.Controls/CoreGalleryPages/CoreGalleryPage.cs
@@ -98,6 +98,19 @@ protected virtual void Build (StackLayout stackLayout)
 				_isVisibleStateViewContainer.View.IsVisible = !_isVisibleStateViewContainer.View.IsVisible;
 			});
 
+
+			_isFocusedStateViewContainer.StateChangeButton.Command = new Command(() => {
+				
+				if ((bool)isFocusedView.GetValue(VisualElement.IsFocusedProperty))
+				{
+					isFocusedView.SetValueCore(IsFocusedPropertyKey, false);
+				}
+				else
+				{
+					isFocusedView.SetValueCore(IsFocusedPropertyKey, true);
+				}
+			});
+
 			_focusStateViewContainer.StateChangeButton.Command = new Command (() => {
 				if (_focusStateViewContainer.View.IsFocused) {
 					_focusStateViewContainer.View.Unfocus ();
diff --git a/Xamarin.Forms.Controls/ViewContainers/StateViewContainer.cs b/Xamarin.Forms.Controls/ViewContainers/StateViewContainer.cs
index b08cc306344..4d53719a9cd 100644
--- a/Xamarin.Forms.Controls/ViewContainers/StateViewContainer.cs
+++ b/Xamarin.Forms.Controls/ViewContainers/StateViewContainer.cs
@@ -24,8 +24,11 @@ public StateViewContainer (Enum formsMember, T view) : base (formsMember, view)
 				BindingContext = view,
 				AutomationId = name + "StateLabel"
 			};
-			if (name != "Focus")
-				stateValueLabel.SetBinding (Label.TextProperty, name, converter: new GenericValueConverter (o => o.ToString()));
+
+			if(name == "Focus" || name == "Unfocused" || name == "Focused")
+				stateValueLabel.SetBinding(Label.TextProperty, "IsFocused", converter: new GenericValueConverter(o => o.ToString()));
+			else
+				stateValueLabel.SetBinding (Label.TextProperty, name, converter: new GenericValueConverter (o => o.ToString()));			
 
 			StateChangeButton = new Button {
 				Text = "Change State: " + name,
diff --git a/Xamarin.Forms.Core.UITests.Shared/Tests/EntryUITests.cs b/Xamarin.Forms.Core.UITests.Shared/Tests/EntryUITests.cs
index c10c4e8534b..348b38ac473 100644
--- a/Xamarin.Forms.Core.UITests.Shared/Tests/EntryUITests.cs
+++ b/Xamarin.Forms.Core.UITests.Shared/Tests/EntryUITests.cs
@@ -1,8 +1,10 @@
 using NUnit.Framework;
+using Xamarin.Forms.Controls.Issues;
 using Xamarin.Forms.CustomAttributes;
 
 namespace Xamarin.Forms.Core.UITests
 {
+
 	[TestFixture]
 	[Category(UITestCategories.Entry)]
 	internal class EntryUITests : _ViewUITests
@@ -17,9 +19,20 @@ protected override void NavigateToGallery()
 			App.NavigateToGallery(GalleryQueries.EntryGallery);
 		}
 
-		// TODO
+		[Test]
+		[UiTest(typeof(Entry), "Focus")]
 		public override void _Focus()
 		{
+			var remote = new StateViewContainerRemote(App, Test.VisualElement.Focus, PlatformViewType);
+			remote.GoTo();
+			bool isFocused = System.Convert.ToBoolean( App.Query("FocusStateLabel")[0].ReadText());
+			Assert.IsFalse(isFocused);
+			remote.TapView();
+			isFocused = System.Convert.ToBoolean(App.Query("FocusStateLabel")[0].ReadText());
+			Assert.IsTrue(isFocused);
+			App.Tap("FocusStateLabel");
+			isFocused = System.Convert.ToBoolean(App.Query("FocusStateLabel")[0].ReadText());
+			Assert.IsFalse(isFocused);
 		}
 
 		[UiTestExempt(ExemptReason.CannotTest, "Invalid interaction")]
@@ -27,7 +40,6 @@ public override void _GestureRecognizers()
 		{
 		}
 
-		// TODO
 		public override void _IsFocused()
 		{
 		}
@@ -37,6 +49,8 @@ public override void _UnFocus()
 		{
 		}
 
+
+		
 		// TODO
 		// Implement control specific ui tests
 		[Test]
diff --git a/Xamarin.Forms.Core.UITests.Shared/Tests/MaterialEntryUITests.cs b/Xamarin.Forms.Core.UITests.Shared/Tests/MaterialEntryUITests.cs
new file mode 100644
index 00000000000..9b83c014a23
--- /dev/null
+++ b/Xamarin.Forms.Core.UITests.Shared/Tests/MaterialEntryUITests.cs
@@ -0,0 +1,27 @@
+using NUnit.Framework;
+using Xamarin.Forms.Controls.Issues;
+using Xamarin.Forms.CustomAttributes;
+
+namespace Xamarin.Forms.Core.UITests
+{
+
+#if __ANDROID__ || __IOS__
+	[TestFixture]
+	[Category(UITestCategories.Entry)]
+	[Category(UITestCategories.Visual)]
+	internal class MaterialEntryUITests : EntryUITests
+	{
+		protected override void NavigateToGallery()
+		{
+			App.NavigateToGallery(GalleryQueries.EntryGallery, "Material");
+		}
+
+		[Test]
+		[UiTest(typeof(Entry), "Focus")]
+		public override void _Focus()
+		{
+			base._Focus();
+		}
+	}
+#endif
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core.UITests.Shared/Utilities/AppExtensions.cs b/Xamarin.Forms.Core.UITests.Shared/Utilities/AppExtensions.cs
index 0e6a9f42cc4..4fedb00a1b1 100644
--- a/Xamarin.Forms.Core.UITests.Shared/Utilities/AppExtensions.cs
+++ b/Xamarin.Forms.Core.UITests.Shared/Utilities/AppExtensions.cs
@@ -9,29 +9,45 @@ namespace Xamarin.Forms.Core.UITests
 {
 	internal static class AppExtensions
 	{
-		public static AppRect ScreenBounds (this IApp app)
+		public static AppRect ScreenBounds(this IApp app)
 		{
-			return app.Query (Queries.Root ()).First().Rect;
+			return app.Query(Queries.Root()).First().Rect;
 		}
 
-		public static void NavigateBack (this IApp app)
+		public static void NavigateBack(this IApp app)
 		{
 			app.Back();
 		}
 
-		public static void NavigateToGallery (this IApp app, string page)
+		public static void NavigateToGallery(this IApp app, string page)
+		{
+			NavigateToGallery(app, page, null);
+		}
+
+		public static void NavigateToGallery(this IApp app, string page, string visual)
 		{
 			const string goToTestButtonQuery = "* marked:'GoToTestButton'";
 
 			app.WaitForElement(q => q.Raw(goToTestButtonQuery), "Timed out waiting for Go To Test button to disappear", TimeSpan.FromSeconds(10));
 
-			var text = Regex.Match (page, "'(?<text>[^']*)'").Groups["text"].Value;
+			var text = Regex.Match(page, "'(?<text>[^']*)'").Groups["text"].Value;
 
 			app.WaitForElement("SearchBar");
-			app.EnterText (q => q.Raw ("* marked:'SearchBar'"), text);
+			app.EnterText(q => q.Raw("* marked:'SearchBar'"), text);
+
+			if(!String.IsNullOrWhiteSpace(visual))
+			{
+				app.DismissKeyboard();
+				app.ActivateContextMenu($"{text}AutomationId");
+				app.Tap("Select Visual");
+				app.Tap("Material");
+			}
+			else
+			{
+				app.Tap(q => q.Raw(goToTestButtonQuery));
+			}
 
-			app.Tap (q => q.Raw (goToTestButtonQuery));
-			app.WaitForNoElement (o => o.Raw (goToTestButtonQuery), "Timed out waiting for Go To Test button to disappear", TimeSpan.FromMinutes(2));
+			app.WaitForNoElement(o => o.Raw(goToTestButtonQuery), "Timed out waiting for Go To Test button to disappear", TimeSpan.FromMinutes(2));
 		}
 
 
@@ -43,10 +59,11 @@ public static AppResult[] QueryNTimes(this IApp app, Func<AppQuery, AppQuery> el
 			{
 				elements = app.Query(elementQuery);
 				tryCount++;
-				if (elements.Length == 0 && onFail != null) onFail();
+				if (elements.Length == 0 && onFail != null)
+					onFail();
 			}
 
 			return elements;
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/Xamarin.Forms.Core.UITests.Shared/Xamarin.Forms.Core.UITests.projitems b/Xamarin.Forms.Core.UITests.Shared/Xamarin.Forms.Core.UITests.projitems
index 6dce2c40b31..f8459866285 100644
--- a/Xamarin.Forms.Core.UITests.Shared/Xamarin.Forms.Core.UITests.projitems
+++ b/Xamarin.Forms.Core.UITests.Shared/Xamarin.Forms.Core.UITests.projitems
@@ -35,6 +35,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Tests\Legacy-CellsUITests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tests\Legacy-UnevenListTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tests\MapUITests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Tests\MaterialEntryUITests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tests\PickerUITests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tests\ProgressBarUITests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tests\RootGalleryUITests.cs" />
diff --git a/Xamarin.Forms.Material.Android/MaterialFormsTextInputLayoutBase.cs b/Xamarin.Forms.Material.Android/MaterialFormsTextInputLayoutBase.cs
index db946f4f460..1d8c22a3625 100644
--- a/Xamarin.Forms.Material.Android/MaterialFormsTextInputLayoutBase.cs
+++ b/Xamarin.Forms.Material.Android/MaterialFormsTextInputLayoutBase.cs
@@ -6,6 +6,8 @@
 using Android.Util;
 using Android.Support.V4.View;
 using Android.Content.Res;
+using AView = Android.Views.View;
+using Xamarin.Forms.Platform.Android.AppCompat;
 
 namespace Xamarin.Forms.Material.Android
 {
@@ -94,9 +96,16 @@ internal void ApplyTheme(Color formsTextColor, Color formsPlaceHolderColor)
 		 * and this is the only way to set it away from that and to whatever the user specified
 		 * 2) The HintTextColor has a different alpha when focused vs not focused
 		 * */
-		void OnFocusChange(object sender, FocusChangeEventArgs e) => 
+		void OnFocusChange(object sender, FocusChangeEventArgs e)
+		{
 			Device.BeginInvokeOnMainThread(() => ApplyTheme());
 
+			// propagate the focus changed event to the View Renderer base class
+			if (Parent is AView.IOnFocusChangeListener focusChangeListener)
+				focusChangeListener.OnFocusChange(EditText, e.HasFocus);
+
+		}
+
 		internal void SetHint(string hint, VisualElement element)
 		{
 			if (HintEnabled != !String.IsNullOrWhiteSpace(hint))
diff --git a/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs b/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs
index 9e9ecacd68e..3b4acc0c985 100644
--- a/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Cells/TextCellRenderer.cs
@@ -1,3 +1,4 @@
+using System;
 using System.ComponentModel;
 using Android.Content;
 using Android.Views;
@@ -20,6 +21,7 @@ protected override AView GetCellCore(Cell item, AView convertView, ViewGroup par
 			UpdateHeight();
 			UpdateIsEnabled();
 			UpdateFlowDirection();
+			UpdateAutomationId();
 			View.SetImageVisible(false);
 
 			return View;
@@ -37,6 +39,13 @@ protected override void OnCellPropertyChanged(object sender, PropertyChangedEven
 				UpdateHeight();
 			else if (args.PropertyName == VisualElement.FlowDirectionProperty.PropertyName)
 				UpdateFlowDirection();
+			else if (args.PropertyName == VisualElement.AutomationIdProperty.PropertyName)
+				UpdateAutomationId();
+		}
+
+		void UpdateAutomationId()
+		{
+			View.ContentDescription = Cell.AutomationId;
 		}
 
 		void UpdateDetailText()
diff --git a/Xamarin.Forms.Platform.Android/ViewRenderer.cs b/Xamarin.Forms.Platform.Android/ViewRenderer.cs
index 42ecc78d17c..fd75649a17b 100644
--- a/Xamarin.Forms.Platform.Android/ViewRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/ViewRenderer.cs
@@ -23,6 +23,7 @@ protected ViewRenderer(Context context) : base(context)
 		[Obsolete("This constructor is obsolete as of version 2.5. Please use ViewRenderer(Context) instead.")]
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		protected ViewRenderer()
+
 		{
 		}
 	}
@@ -37,6 +38,7 @@ protected ViewRenderer(Context context) : base(context)
 		[EditorBrowsable(EditorBrowsableState.Never)]
 		protected ViewRenderer() 
 		{
+			
 		}
 
 		protected virtual TNativeView CreateNativeControl()
diff --git a/Xamarin.Forms.Platform.UAP/Resources.xaml b/Xamarin.Forms.Platform.UAP/Resources.xaml
index ca90517eb57..246efe337ed 100644
--- a/Xamarin.Forms.Platform.UAP/Resources.xaml
+++ b/Xamarin.Forms.Platform.UAP/Resources.xaml
@@ -236,7 +236,7 @@
     </Style>
 
     <DataTemplate x:Key="TextCell">
-		<StackPanel>
+		<StackPanel AutomationProperties.AutomationId="{Binding AutomationId}">
 			<TextBlock
 				Text="{Binding Text}"
 				Style="{ThemeResource BaseTextBlockStyle}"
diff --git a/Xamarin.Forms.Platform.iOS/Cells/TextCellRenderer.cs b/Xamarin.Forms.Platform.iOS/Cells/TextCellRenderer.cs
index 7568e5046ed..e635db96b49 100644
--- a/Xamarin.Forms.Platform.iOS/Cells/TextCellRenderer.cs
+++ b/Xamarin.Forms.Platform.iOS/Cells/TextCellRenderer.cs
@@ -34,6 +34,7 @@ public override UITableViewCell GetCell(Cell item, UITableViewCell reusableCell,
 			UpdateBackground(tvc, item);
 
 			SetAccessibility(tvc, item);
+			UpdateAutomationId(tvc, textCell);
 
 			return tvc;
 		}
@@ -59,9 +60,15 @@ protected virtual void HandleCellPropertyChanged(object sender, PropertyChangedE
 				tvc.DetailTextLabel.TextColor = textCell.DetailColor.ToUIColor(DefaultTextColor);
 			else if (args.PropertyName == Cell.IsEnabledProperty.PropertyName)
 				UpdateIsEnabled(tvc, textCell);
+			else if (args.PropertyName == TextCell.AutomationIdProperty.PropertyName)
+				UpdateAutomationId(tvc, textCell);
 
 			HandlePropertyChanged(tvc, args);
 		}
+		void UpdateAutomationId(CellTableViewCell tvc, TextCell cell)
+		{
+			tvc.AccessibilityIdentifier = cell.AutomationId;
+		}
 
 		protected virtual void HandlePropertyChanged(object sender, PropertyChangedEventArgs args)
 		{

From ecfe41bf5d4c9105c25d30e2837d5387ffe94281 Mon Sep 17 00:00:00 2001
From: Rui Marinho <me@ruimarinho.net>
Date: Fri, 15 Mar 2019 21:45:17 +0000
Subject: [PATCH 21/25] =?UTF-8?q?[Shell,Core]=C2=A0Add=20better=20exceptio?=
 =?UTF-8?q?n=20messages=20for=20wrong=20or=20non=20existing=20content=20(#?=
 =?UTF-8?q?5566)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

fixes #5081
---
 Xamarin.Forms.Core/Shell/ShellContent.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Xamarin.Forms.Core/Shell/ShellContent.cs b/Xamarin.Forms.Core/Shell/ShellContent.cs
index 524d6e88c04..738fb78fcb4 100644
--- a/Xamarin.Forms.Core/Shell/ShellContent.cs
+++ b/Xamarin.Forms.Core/Shell/ShellContent.cs
@@ -61,6 +61,8 @@ Page IShellContentController.GetOrCreateContent()
 			if (result != null && result.Parent != this)
 				OnChildAdded(result);
 
+			if (result == null)
+				throw new InvalidOperationException($"No Content found for {nameof(ShellContent)}, Title:{Title}, Route {Route}");
 
 			if (_delayedQueryParams != null && result  != null) {
 				ApplyQueryAttributes(result, _delayedQueryParams);
@@ -138,6 +140,10 @@ static void OnContentChanged(BindableObject bindable, object oldValue, object ne
 					// parent new item
 					shellContent.OnChildAdded(newElement);
 				}
+				else if(newValue != null)
+				{
+					throw new InvalidOperationException($"{nameof(ShellContent)} {nameof(Content)} should be of type {nameof(Page)}. Title {shellContent?.Title}, Route {shellContent?.Route} ");
+				}
 			}
 
 			if (shellContent.Parent?.Parent is ShellItem shellItem)

From 7c71feec260ac119247556fe8adf2aa9103483a5 Mon Sep 17 00:00:00 2001
From: Akihiko Odaki <akihiko.odaki.4i@stu.hosei.ac.jp>
Date: Sat, 16 Mar 2019 07:12:57 +0900
Subject: [PATCH 22/25] [XamlC] Resolve complex property type (#5086)

---
 .../BindablePropertyReferenceExtensions.cs    |  2 +-
 .../PropertyDefinitionExtensions.cs           | 21 -------
 .../SetPropertiesVisitor.cs                   |  8 +--
 .../TypeReferenceExtensions.cs                | 20 +++++-
 .../PropertyDefinitionExtensionsTests.cs      | 62 -------------------
 .../XamlC/TypeReferenceExtensionsTests.cs     | 11 ++++
 6 files changed, 34 insertions(+), 90 deletions(-)
 delete mode 100644 Xamarin.Forms.Build.Tasks/PropertyDefinitionExtensions.cs
 delete mode 100644 Xamarin.Forms.Xaml.UnitTests/XamlC/PropertyDefinitionExtensionsTests.cs

diff --git a/Xamarin.Forms.Build.Tasks/BindablePropertyReferenceExtensions.cs b/Xamarin.Forms.Build.Tasks/BindablePropertyReferenceExtensions.cs
index a2930579054..641232b958a 100644
--- a/Xamarin.Forms.Build.Tasks/BindablePropertyReferenceExtensions.cs
+++ b/Xamarin.Forms.Build.Tasks/BindablePropertyReferenceExtensions.cs
@@ -38,7 +38,7 @@ public static TypeReference GetBindablePropertyTypeConverter(this FieldReference
 			var owner = bpRef.DeclaringType;
 			var bpName = bpRef.Name.EndsWith("Property", StringComparison.Ordinal) ? bpRef.Name.Substring(0, bpRef.Name.Length - 8) : bpRef.Name;
 			var property = owner.GetProperty(pd => pd.Name == bpName, out propertyDeclaringType);
-			var propertyType = property?.ResolveGenericPropertyType(propertyDeclaringType, module);
+			var propertyType = property?.PropertyType?.ResolveGenericParameters(propertyDeclaringType);
 			var staticGetter = owner.GetMethods(md => md.Name == $"Get{bpName}" &&
 												md.IsStatic &&
 												md.IsPublic &&
diff --git a/Xamarin.Forms.Build.Tasks/PropertyDefinitionExtensions.cs b/Xamarin.Forms.Build.Tasks/PropertyDefinitionExtensions.cs
deleted file mode 100644
index 8cbbbe4a954..00000000000
--- a/Xamarin.Forms.Build.Tasks/PropertyDefinitionExtensions.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-using Mono.Cecil;
-
-namespace Xamarin.Forms.Build.Tasks
-{
-	static class PropertyDefinitionExtensions
-	{
-		public static TypeReference ResolveGenericPropertyType(this PropertyDefinition self, TypeReference declaringTypeRef,
-			ModuleDefinition module)
-		{
-			if (self == null)
-				throw new ArgumentNullException(nameof(self));
-			if (declaringTypeRef == null)
-				throw new ArgumentNullException(nameof(declaringTypeRef));
-			if (!self.PropertyType.IsGenericParameter)
-				return self.PropertyType;
-
-			return ((GenericInstanceType)declaringTypeRef).GenericArguments [((GenericParameter)self.PropertyType).Position];
-		}
-	}
-}
\ No newline at end of file
diff --git a/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs b/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
index 0d455f69477..df8ac79de76 100644
--- a/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
+++ b/Xamarin.Forms.Build.Tasks/SetPropertiesVisitor.cs
@@ -396,7 +396,7 @@ static IEnumerable<Instruction> CompileBindingPath(ElementNode node, ILContext c
 			TypeReference tPropertyRef = tSourceRef;
 			if (properties != null && properties.Count > 0) {
 				var lastProp = properties[properties.Count - 1];
-				tPropertyRef = lastProp.property.ResolveGenericPropertyType(lastProp.propDeclTypeRef, module);
+				tPropertyRef = lastProp.property.PropertyType.ResolveGenericParameters(lastProp.propDeclTypeRef);
 			}
 			tPropertyRef = module.ImportReference(tPropertyRef);
 			var valuetupleRef = context.Module.ImportReference(module.ImportReference(("mscorlib", "System", "ValueTuple`2")).MakeGenericInstanceType(new[] { tPropertyRef, module.TypeSystem.Boolean }));
@@ -478,7 +478,7 @@ static IEnumerable<Instruction> CompileBindingPath(ElementNode node, ILContext c
 					var indexType = indexer.GetMethod.Parameters[0].ParameterType;
 					if (!TypeRefComparer.Default.Equals(indexType, module.TypeSystem.String) && !TypeRefComparer.Default.Equals(indexType, module.TypeSystem.Int32))
 						throw new XamlParseException($"Binding: Unsupported indexer index type: {indexType.FullName}", lineInfo);
-					previousPartTypeRef = indexer.ResolveGenericPropertyType(indexerDeclTypeRef, module);
+					previousPartTypeRef = indexer.PropertyType.ResolveGenericParameters(indexerDeclTypeRef);
 				}
 			}
 			return properties;
@@ -1160,7 +1160,7 @@ static bool CanSet(VariableDefinition parent, string localName, INode node, ILCo
 			var property = parent.VariableType.GetProperty(pd => pd.Name == localName, out declaringTypeReference);
 			if (property == null)
 				return false;
-			var propertyType = property.ResolveGenericPropertyType(declaringTypeReference, module);
+			var propertyType = property.PropertyType.ResolveGenericParameters(declaringTypeReference);
 			var propertySetter = property.SetMethod;
 			if (propertySetter == null || !propertySetter.IsPublic || propertySetter.IsStatic)
 				return false;
@@ -1224,7 +1224,7 @@ static IEnumerable<Instruction> Set(VariableDefinition parent, string localName,
 			module.ImportReference(parent.VariableType.ResolveCached());
 			var propertySetterRef = module.ImportReference(module.ImportReference(propertySetter).ResolveGenericParameters(declaringTypeReference, module));
 			propertySetterRef.ImportTypes(module);
-			var propertyType = property.ResolveGenericPropertyType(declaringTypeReference, module);
+			var propertyType = property.PropertyType.ResolveGenericParameters(declaringTypeReference);
 			var valueNode = node as ValueNode;
 			var elementNode = node as IElementNode;
 
diff --git a/Xamarin.Forms.Build.Tasks/TypeReferenceExtensions.cs b/Xamarin.Forms.Build.Tasks/TypeReferenceExtensions.cs
index ac97e17dfe9..2dc73fe086a 100644
--- a/Xamarin.Forms.Build.Tasks/TypeReferenceExtensions.cs
+++ b/Xamarin.Forms.Build.Tasks/TypeReferenceExtensions.cs
@@ -368,8 +368,19 @@ public static TypeReference ResolveGenericParameters(this TypeReference self, Me
 
 		public static TypeReference ResolveGenericParameters(this TypeReference self, TypeReference declaringTypeReference)
 		{
+			var genericdeclType = declaringTypeReference as GenericInstanceType;
+			if (genericdeclType == null)
+				return self;
+
+			var genericParameterSelf = self as GenericParameter;
+			if (genericParameterSelf != null)
+				return genericdeclType.GenericArguments[genericParameterSelf.Position];
+
 			var genericself = self as GenericInstanceType;
-			return genericself == null ? self : genericself.ResolveGenericParameters(declaringTypeReference);
+			if (genericself != null)
+				return genericself.ResolveGenericParameters(declaringTypeReference);
+
+			return self;
 		}
 
 		public static GenericInstanceType ResolveGenericParameters(this GenericInstanceType self, TypeReference declaringTypeReference)
@@ -378,13 +389,18 @@ public static GenericInstanceType ResolveGenericParameters(this GenericInstanceT
 			if (genericdeclType == null)
 				return self;
 
+			return self.ResolveGenericParameters(genericdeclType);
+		}
+
+		public static GenericInstanceType ResolveGenericParameters(this GenericInstanceType self, GenericInstanceType declaringTypeReference)
+		{
 			List<TypeReference> args = new List<TypeReference>();
 			for (var i = 0; i < self.GenericArguments.Count; i++) {
 				var genericParameter = self.GenericArguments[i] as GenericParameter;
 				if (genericParameter == null)
 					args.Add(self.GenericArguments[i].ResolveGenericParameters(declaringTypeReference));
 				else if (genericParameter.Type == GenericParameterType.Type)
-					args.Add(genericdeclType.GenericArguments[genericParameter.Position]);
+					args.Add(declaringTypeReference.GenericArguments[genericParameter.Position]);
 			}
 			return self.ElementType.MakeGenericInstanceType(args.ToArray());
 		}
diff --git a/Xamarin.Forms.Xaml.UnitTests/XamlC/PropertyDefinitionExtensionsTests.cs b/Xamarin.Forms.Xaml.UnitTests/XamlC/PropertyDefinitionExtensionsTests.cs
deleted file mode 100644
index 93146ac9c7f..00000000000
--- a/Xamarin.Forms.Xaml.UnitTests/XamlC/PropertyDefinitionExtensionsTests.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-using System;
-using System.Linq;
-
-using Mono.Cecil;
-
-using Xamarin.Forms.Build.Tasks;
-
-using NUnit.Framework;
-using System.Collections.Generic;
-
-namespace Xamarin.Forms.XamlcUnitTests
-{
-	[TestFixture]
-	public class PropertyDefinitionExtensionsTests
-	{
-		public class NonGenericClass
-		{
-			public object Property { get; set; }
-		}
-
-		public class GenericClass<T, U, V>
-		{
-			public object Property { get; set; }
-			public T GenericT { get; set; }
-			public U GenericU { get; set; }
-			public V GenericV { get; set; }
-			public IEnumerable<T> EnumerableT { get; set; }
-			public KeyValuePair<V, U> KvpVU { get; set; }
-		}
-
-		ModuleDefinition module;
-
-		[SetUp]
-		public void SetUp ()
-		{
-			module = ModuleDefinition.CreateModule ("foo", ModuleKind.Dll);
-		}
-
-		[Test]
-		public void ResolveGenericPropertyType ()
-		{
-			var type = module.ImportReference (typeof (GenericClass<bool, string, int>));
-			TypeReference declaringTypeReference;
-			var prop = type.GetProperty (fd => fd.Name == "Property", out declaringTypeReference);
-			var propertyType = prop.ResolveGenericPropertyType (declaringTypeReference, module);
-			Assert.AreEqual ("System.Object", propertyType.FullName);
-
-			prop = type.GetProperty(fd => fd.Name == "GenericT", out declaringTypeReference);
-			propertyType = prop.ResolveGenericPropertyType(declaringTypeReference, module);
-			Assert.AreEqual("System.Boolean", propertyType.FullName);
-
-			prop = type.GetProperty(fd => fd.Name == "GenericU", out declaringTypeReference);
-			propertyType = prop.ResolveGenericPropertyType(declaringTypeReference, module);
-			Assert.AreEqual("System.String", propertyType.FullName);
-
-			prop = type.GetProperty(fd => fd.Name == "GenericV", out declaringTypeReference);
-			propertyType = prop.ResolveGenericPropertyType(declaringTypeReference, module);
-			Assert.AreEqual("System.Int32", propertyType.FullName);
-
-		}
-	}
-}
\ No newline at end of file
diff --git a/Xamarin.Forms.Xaml.UnitTests/XamlC/TypeReferenceExtensionsTests.cs b/Xamarin.Forms.Xaml.UnitTests/XamlC/TypeReferenceExtensionsTests.cs
index 8706602a693..97c6b838a8b 100644
--- a/Xamarin.Forms.Xaml.UnitTests/XamlC/TypeReferenceExtensionsTests.cs
+++ b/Xamarin.Forms.Xaml.UnitTests/XamlC/TypeReferenceExtensionsTests.cs
@@ -151,6 +151,17 @@ public void TestSameTypeNamesFromDifferentAssemblies()
 			Assert.False(TestInheritsFromOrImplements(test.GetType("Xamarin.Forms.Effect"), core.GetType("Xamarin.Forms.Effect")));
 		}
 
+		[Test]
+		public void TestResolveSelectedGenericParameter()
+		{
+			var imported = module.ImportReference(typeof(Bar<byte>));
+			var baseType = (GenericInstanceType)imported.Resolve().BaseType;
+			var resolvedType = baseType.GenericArguments[0].ResolveGenericParameters(imported);
+
+			Assert.AreEqual("System", resolvedType.Namespace);
+			Assert.AreEqual("Byte", resolvedType.Name);
+		}
+
 		[TestCase(typeof(Bar<byte>), 1)]
 		[TestCase(typeof(Quux<byte>), 2)]
 		[TestCase(typeof(Corge<byte>), 3)]

From 13eb0970629cead3c0b5b660fbfd2b518b66bdbe Mon Sep 17 00:00:00 2001
From: Rui Marinho <me@ruimarinho.net>
Date: Sat, 16 Mar 2019 01:13:14 +0000
Subject: [PATCH 23/25] =?UTF-8?q?[Android]=C2=A0Fix=20issue=20when=20Messa?=
 =?UTF-8?q?ge=20is=20null=20on=20Android=20API19=20(#5562)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* [Android] Fix issue when Message is null on Android API19

* added kitkat check and moved check to extension method

* - remove awaken for kit kat and just catch all NPE

* - remove using
---
 .../Extensions/ScrollViewExtensions.cs                         | 2 ++
 .../Renderers/AHorizontalScrollView.cs                         | 3 +--
 Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs | 3 +--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs b/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs
index a392bb9efa9..ef7f44a684a 100644
--- a/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs
+++ b/Xamarin.Forms.Platform.Android/Extensions/ScrollViewExtensions.cs
@@ -16,6 +16,8 @@ internal static class ScrollViewExtensions
 	{
 		internal static void HandleScrollBarVisibilityChange(this IScrollView scrollView)
 		{
+			if (Build.VERSION.SdkInt <= BuildVersionCodes.Kitkat)
+				return;
 
 			// According to the Android Documentation
 			// * <p>AwakenScrollBars method should be invoked every time a subclass directly updates
diff --git a/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs b/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs
index bb1aec74adb..5c357562c75 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/AHorizontalScrollView.cs
@@ -76,8 +76,7 @@ public override void Draw(Canvas canvas)
 			{
 				base.Draw(canvas);
 			}
-			catch (Java.Lang.NullPointerException npe)
-			when (npe.Message.Contains("ScrollBarDrawable.mutate()"))
+			catch (Java.Lang.NullPointerException)
 			{
 				// This will most likely never run since UpdateScrollBars is called 
 				// when the scrollbars visibilities are updated but I left it here
diff --git a/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs b/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs
index f45b98a3728..0d9cdbd5f93 100644
--- a/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs
+++ b/Xamarin.Forms.Platform.Android/Renderers/ScrollViewRenderer.cs
@@ -143,8 +143,7 @@ public override void Draw(Canvas canvas)
 
 				base.Draw(canvas);
 			}
-			catch (Java.Lang.NullPointerException npe)
-			when(npe.Message.Contains("ScrollBarDrawable.mutate()"))
+			catch (Java.Lang.NullPointerException)
 			{
 				// This will most likely never run since UpdateScrollBars is called 
 				// when the scrollbars visibilities are updated but I left it here

From 6ce52612e2cec3b8eda12efb9fbb1ff9b4586ae6 Mon Sep 17 00:00:00 2001
From: Shane Neuville <shane94@hotmail.com>
Date: Fri, 15 Mar 2019 19:19:53 -0600
Subject: [PATCH 24/25] remove left over sealed on Material Entry Renderer
 (#5586)

---
 Xamarin.Forms.Material.Android/MaterialEntryRenderer.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Xamarin.Forms.Material.Android/MaterialEntryRenderer.cs b/Xamarin.Forms.Material.Android/MaterialEntryRenderer.cs
index b7afe878f1b..060179c65a5 100644
--- a/Xamarin.Forms.Material.Android/MaterialEntryRenderer.cs
+++ b/Xamarin.Forms.Material.Android/MaterialEntryRenderer.cs
@@ -10,7 +10,7 @@
 [assembly: ExportRenderer(typeof(Xamarin.Forms.Entry), typeof(MaterialEntryRenderer), new[] { typeof(VisualMarker.MaterialVisual) })]
 namespace Xamarin.Forms.Material.Android
 {
-	public sealed class MaterialEntryRenderer : EntryRendererBase<MaterialFormsTextInputLayout>
+	public class MaterialEntryRenderer : EntryRendererBase<MaterialFormsTextInputLayout>
 	{
 		MaterialFormsEditText _textInputEditText;
 		MaterialFormsTextInputLayout _textInputLayout;

From 21eb50bc47b989a04b3ea9a20d31d86b28687a2d Mon Sep 17 00:00:00 2001
From: Pavel Yakovlev <v-payako@microsoft.com>
Date: Mon, 18 Mar 2019 17:48:21 +0300
Subject: [PATCH 25/25] [mac] disregard the Dark mode (#5537) fixes #3777

---
 Xamarin.Forms.Platform.iOS/Forms.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Xamarin.Forms.Platform.iOS/Forms.cs b/Xamarin.Forms.Platform.iOS/Forms.cs
index 47b925dd0fb..5530f7a610b 100644
--- a/Xamarin.Forms.Platform.iOS/Forms.cs
+++ b/Xamarin.Forms.Platform.iOS/Forms.cs
@@ -97,6 +97,9 @@ public static void Init()
 #else
 			Device.SetIdiom(TargetIdiom.Desktop);
 			Device.SetFlowDirection(NSApplication.SharedApplication.UserInterfaceLayoutDirection.ToFlowDirection());
+			var mojave = new NSOperatingSystemVersion(10, 14, 0);
+			if (NSProcessInfo.ProcessInfo.IsOperatingSystemAtLeastVersion(mojave))
+				NSApplication.SharedApplication.Appearance = NSAppearance.GetAppearance(NSAppearance.NameAqua);
 #endif
 			Device.SetFlags(s_flags);
 			Device.PlatformServices = new IOSPlatformServices();