From d843c2ae83c53c265046566cb7f9af30cdf06b4a Mon Sep 17 00:00:00 2001
From: Chase Florell <chase.florell@gmail.com>
Date: Wed, 27 Dec 2017 13:28:04 -0800
Subject: [PATCH 1/3] [CF] formatting

---
 example/Xfx.Controls.Example/MainPage.xaml             |  6 ++++--
 .../Renderers/XfxCardViewRendererDroid.cs              |  4 ++--
 src/Xfx.Controls/XfxCardView.cs                        | 10 +++++-----
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/example/Xfx.Controls.Example/MainPage.xaml b/example/Xfx.Controls.Example/MainPage.xaml
index 4aaf19a..b39fd61 100644
--- a/example/Xfx.Controls.Example/MainPage.xaml
+++ b/example/Xfx.Controls.Example/MainPage.xaml
@@ -36,11 +36,13 @@
                            Aspect="Fill" />
                     <Label Margin="8">
                         <Label.Text>
-                            Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse fringilla turpis turpis, id lobortis dolor vestibulum condimentum.
+                            Tap this card to navigate to the next page
                         </Label.Text>
                     </Label>
-                    <Button Text="Go to Main Page" Clicked="Button_OnClicked" Margin="8" />
                 </StackLayout>
+                <xfx:XfxCardView.GestureRecognizers>
+                    <TapGestureRecognizer Tapped="Button_OnClicked"/>
+                </xfx:XfxCardView.GestureRecognizers>
             </xfx:XfxCardView>
         </StackLayout>
     </ScrollView>
diff --git a/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs b/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs
index 4bca3f7..d6d16f4 100644
--- a/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs
+++ b/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs
@@ -6,7 +6,7 @@
 using Xamarin.Forms.Platform.Android;
 using Xfx;
 using Xfx.Controls.Droid.Renderers;
-
+using AContext = Android.Content.Context;
 [assembly: ExportRenderer(typeof(XfxCardView), typeof(XfxCardViewRendererDroid))]
 
 namespace Xfx.Controls.Droid.Renderers
@@ -16,7 +16,7 @@ public class XfxCardViewRendererDroid : CardView, IVisualElementRenderer
         private float _defaultElevation;
         private float _defaultCornerRadius;
 
-        public XfxCardViewRendererDroid() : base(Forms.Context)
+        public XfxCardViewRendererDroid(AContext context) : base(context)
         {
         }
 
diff --git a/src/Xfx.Controls/XfxCardView.cs b/src/Xfx.Controls/XfxCardView.cs
index f476f59..cccc6ec 100644
--- a/src/Xfx.Controls/XfxCardView.cs
+++ b/src/Xfx.Controls/XfxCardView.cs
@@ -20,15 +20,15 @@ public XfxCardView()
         public static readonly BindableProperty ElevationProperty = BindableProperty.Create(nameof(Elevation),
             typeof(float),
             typeof(XfxCardView),
-            -1f);
+            default(float));
 
         /// <summary>
         ///    Corner Radius. This is a bindable property. Default is 3.0f
         /// </summary>
         public float CornerRadius
         {
-            get { return (float)GetValue(CornerRadiusProperty); }
-            set { SetValue(CornerRadiusProperty, value); }
+            get => (float)GetValue(CornerRadiusProperty);
+            set => SetValue(CornerRadiusProperty, value);
         }
 
         /// <summary>
@@ -37,8 +37,8 @@ public float CornerRadius
         /// <value>The elevation.</value>
         public float Elevation
         {
-            get { return (float)GetValue(ElevationProperty); }
-            set{SetValue(ElevationProperty, value);}
+            get => (float)GetValue(ElevationProperty);
+            set => SetValue(ElevationProperty, value);
         }
 
         protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint)

From 7c50f1d910e935c6e82f4814fc281d061be05f2c Mon Sep 17 00:00:00 2001
From: Chase Florell <chase.florell@gmail.com>
Date: Wed, 27 Dec 2017 22:02:40 -0800
Subject: [PATCH 2/3] [CF] added gesture recogizer support for iOS CardView

---
 example/Xfx.Controls.Example/MainPage.xaml    |  2 +
 src/Xfx.Controls.iOS/Controls/UICardView.cs   |  2 +-
 .../InvalidRendererException.cs               | 11 +++
 .../Renderers/XfxCardViewRendererTouch.cs     | 78 ++++++++++--------
 src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj  |  1 +
 .../XfxVisualElementManager.cs                | 81 +++++++++++++++++++
 src/Xfx.Controls/XfxCardView.cs               |  2 +-
 7 files changed, 141 insertions(+), 36 deletions(-)
 create mode 100644 src/Xfx.Controls.iOS/InvalidRendererException.cs
 create mode 100644 src/Xfx.Controls.iOS/XfxVisualElementManager.cs

diff --git a/example/Xfx.Controls.Example/MainPage.xaml b/example/Xfx.Controls.Example/MainPage.xaml
index b39fd61..4fc4b6d 100644
--- a/example/Xfx.Controls.Example/MainPage.xaml
+++ b/example/Xfx.Controls.Example/MainPage.xaml
@@ -37,6 +37,8 @@
                     <Label Margin="8">
                         <Label.Text>
                             Tap this card to navigate to the next page
+                            
+                            Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse fringilla turpis turpis, id lobortis dolor vestibulum condimentum.
                         </Label.Text>
                     </Label>
                 </StackLayout>
diff --git a/src/Xfx.Controls.iOS/Controls/UICardView.cs b/src/Xfx.Controls.iOS/Controls/UICardView.cs
index 418c8a8..50cd34b 100644
--- a/src/Xfx.Controls.iOS/Controls/UICardView.cs
+++ b/src/Xfx.Controls.iOS/Controls/UICardView.cs
@@ -24,7 +24,7 @@ public override void MovedToSuperview()
             Superview.InsertSubviewBelow(_shadowLayer, this);
         }
 
-        protected void DrawBorder(CGRect rect, nfloat radius)
+        public void DrawBorder(CGRect rect, nfloat radius)
         {
             _shadowLayer.Frame = rect;
             _shadowLayer.Layer.CornerRadius = radius;
diff --git a/src/Xfx.Controls.iOS/InvalidRendererException.cs b/src/Xfx.Controls.iOS/InvalidRendererException.cs
new file mode 100644
index 0000000..91a05ad
--- /dev/null
+++ b/src/Xfx.Controls.iOS/InvalidRendererException.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace Xfx.Controls.iOS
+{
+    public class InvalidRendererException : Exception
+    {
+        public InvalidRendererException(string message):base(message)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs b/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs
index 1ec6c40..784b16a 100644
--- a/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs
+++ b/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs
@@ -14,41 +14,36 @@ namespace Xfx.Controls.iOS.Renderers
 {
     public class XfxCardViewRendererTouch : UICardView, IVisualElementRenderer
     {
-        public VisualElementTracker Tracker { get; private set; }
-        public VisualElementPackager Packager { get; private set; }
+        private XfxVisualElementManager _xfxVisualElementManager;
+
+        protected XfxCardView CardView => (XfxCardView) Element;
+
         public event EventHandler<VisualElementChangedEventArgs> ElementChanged;
         public event EventHandler<PropertyChangedEventArgs> ElementPropertyChanged;
+
         public VisualElement Element { get; private set; }
-        public UIView NativeView => this;
-        public UIViewController ViewController => null;
         public SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint) => NativeView.GetSizeRequest(widthConstraint, heightConstraint, 44.0, 44.0);
+        public UIView NativeView => this;
         public void SetElementSize(Size size) => Element.Layout(new Rectangle(Element.X, Element.Y, size.Width, size.Height));
-        protected XfxCardView CardView => (XfxCardView)Element;
-        protected virtual void OnElementChanged(object sender, VisualElementChangedEventArgs args) { }
-        protected virtual void OnElementPropertyChanged(object sender, PropertyChangedEventArgs args) { }
-        private void SetElevation() => SetElevation(CardView.Elevation);
-        private void SetCardBackgroundColor() => BackgroundColor = CardView.BackgroundColor.ToUIColor();
+        public UIViewController ViewController => null;
 
         public void SetElement(VisualElement element)
         {
             var oldElement = Element;
 
             if (oldElement != null)
-            {
                 oldElement.PropertyChanged -= HandlePropertyChanged;
-            }
 
             Element = element;
 
             if (Element != null)
-            {
                 Element.PropertyChanged += HandlePropertyChanged;
-            }
 
             this.RemoveAllSubviews();
-            Tracker = new VisualElementTracker(this);
-            Packager = new VisualElementPackager(this);
-            Packager.Load();
+
+            _xfxVisualElementManager = new XfxVisualElementManager();
+            _xfxVisualElementManager.Init(this);
+
             var view = Element as XfxCardView;
             if (view == null) return;
             SetCardBackgroundColor();
@@ -56,51 +51,66 @@ public void SetElement(VisualElement element)
             RaiseElementChanged(new VisualElementChangedEventArgs(oldElement, Element));
         }
 
-        private void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
+        protected virtual void OnElementChanged(object sender, VisualElementChangedEventArgs args){ }
+
+        protected virtual void OnElementPropertyChanged(object sender, PropertyChangedEventArgs args){ }
+
+        protected override void Dispose(bool disposing)
         {
-            var view = (XfxCardView)Element;
+            base.Dispose(disposing);
+            _xfxVisualElementManager.Dispose();
+        }
 
+        private void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
             if (e.PropertyName == "Content")
             {
                 //Tracker.UpdateLayout ();
             }
             else if (
-                (e.PropertyName == VisualElement.WidthProperty.PropertyName) ||
-                (e.PropertyName == VisualElement.HeightProperty.PropertyName) ||
-                (e.PropertyName == VisualElement.XProperty.PropertyName) ||
-                (e.PropertyName == VisualElement.YProperty.PropertyName) ||
-                (e.PropertyName == XfxCardView.CornerRadiusProperty.PropertyName) ||
-                (e.PropertyName == XfxCardView.ElevationProperty.PropertyName))
+                e.PropertyName == VisualElement.WidthProperty.PropertyName ||
+                e.PropertyName == VisualElement.HeightProperty.PropertyName ||
+                e.PropertyName == VisualElement.XProperty.PropertyName ||
+                e.PropertyName == VisualElement.YProperty.PropertyName ||
+                e.PropertyName == XfxCardView.CornerRadiusProperty.PropertyName ||
+                e.PropertyName == XfxCardView.ElevationProperty.PropertyName)
             {
                 Element.Layout(Element.Bounds);
 
-                var radius = ((XfxCardView)Element).CornerRadius;
-                var bound = Element.Bounds;
-                var rect = new CGRect(bound.X, bound.Y, bound.Width, bound.Height);
-                var elevation = ((XfxCardView)Element).Elevation;
+                var radius = CardView.CornerRadius;
+                var rect = new CGRect(Element.Bounds.X, Element.Bounds.Y, Element.Bounds.Width, Element.Bounds.Height);
                 DrawBorder(rect, radius);
             }
             else if (e.PropertyName == VisualElement.BackgroundColorProperty.PropertyName)
+            {
                 SetCardBackgroundColor();
+            }
             else if (e.PropertyName == XfxCardView.ElevationProperty.PropertyName)
+            {
                 SetElevation();
+            }
             RaiseElementPropertyChanged(e);
         }
 
+        private void RaiseElementChanged(VisualElementChangedEventArgs args)
+        {
+            ElementChanged?.Invoke(this, args);
+            OnElementChanged(this, args);
+        }
+
         private void RaiseElementPropertyChanged(PropertyChangedEventArgs args)
         {
             ElementPropertyChanged?.Invoke(this, args);
             OnElementPropertyChanged(this, args);
         }
 
-        private void RaiseElementChanged(VisualElementChangedEventArgs args)
-        {
-            ElementChanged?.Invoke(this, args);
-            OnElementChanged(this, args);
-        }
+        private void SetCardBackgroundColor() => BackgroundColor = CardView.BackgroundColor.ToUIColor();
+
+        private void SetElevation() => SetElevation(CardView.Elevation);
     }
 
-    static class Extensions
+
+    internal static class Extensions
     {
         internal static void RemoveAllSubviews(this UIView super)
         {
diff --git a/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj b/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj
index 489f214..3bc3374 100644
--- a/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj
+++ b/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj
@@ -100,6 +100,7 @@
     <Compile Include="Extensions\FontExtensions.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Extensions\UIViewExtensions.cs" />
+    <Compile Include="XfxVisualElementManager.cs" />
     <Compile Include="Renderers\XfxCardViewRendererTouch.cs" />
     <Compile Include="Renderers\XfxEntryRendererTouch.cs" />
     <Compile Include="Renderers\XfxComboBoxRendererTouch.cs" />
diff --git a/src/Xfx.Controls.iOS/XfxVisualElementManager.cs b/src/Xfx.Controls.iOS/XfxVisualElementManager.cs
new file mode 100644
index 0000000..b2507a8
--- /dev/null
+++ b/src/Xfx.Controls.iOS/XfxVisualElementManager.cs
@@ -0,0 +1,81 @@
+using System;
+using UIKit;
+using Xamarin.Forms.Platform.iOS;
+
+namespace Xfx.Controls.iOS
+{
+    public class XfxVisualElementManager : IDisposable
+    {
+        private EventTracker _events;
+        private VisualElementRendererFlags _flags = VisualElementRendererFlags.AutoPackage | VisualElementRendererFlags.AutoTrack;
+        private VisualElementPackager _packager;
+        private VisualElementTracker _tracker;
+
+        public bool AutoPackage
+        {
+            get => (_flags & VisualElementRendererFlags.AutoPackage) != 0;
+            set
+            {
+                if (value)
+                    _flags |= VisualElementRendererFlags.AutoPackage;
+                else
+                    _flags &= ~VisualElementRendererFlags.AutoPackage;
+            }
+        }
+
+        public bool AutoTrack
+        {
+            get => (_flags & VisualElementRendererFlags.AutoTrack) != 0;
+            set
+            {
+                if (value)
+                    _flags |= VisualElementRendererFlags.AutoTrack;
+                else
+                    _flags &= ~VisualElementRendererFlags.AutoTrack;
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_events != null)
+            {
+                _events.Dispose();
+                _events = null;
+            }
+            if (_tracker != null)
+            {
+                _tracker.Dispose();
+                _tracker = null;
+            }
+            if (_packager != null)
+            {
+                _packager.Dispose();
+                _packager = null;
+            }
+        }
+
+        public void Init(IVisualElementRenderer renderer)
+        {
+            _tracker = new VisualElementTracker(renderer);
+            _tracker.NativeControlUpdated += OnNativeControlUpdated;
+
+            _packager = new VisualElementPackager(renderer);
+            _events = new EventTracker(renderer);
+
+            if (AutoPackage)
+                _packager?.Load();
+
+            if (AutoTrack)
+                if (renderer is UIView uiView)
+                    _events.LoadEvents(uiView);
+                else
+                    throw new InvalidRendererException("IVisualElementRenderer must be of type 'UIView'");
+        }
+
+        protected virtual void UpdateNativeWidget()
+        {
+        }
+
+        private void OnNativeControlUpdated(object sender, EventArgs e) => UpdateNativeWidget();
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls/XfxCardView.cs b/src/Xfx.Controls/XfxCardView.cs
index cccc6ec..e50ba2e 100644
--- a/src/Xfx.Controls/XfxCardView.cs
+++ b/src/Xfx.Controls/XfxCardView.cs
@@ -20,7 +20,7 @@ public XfxCardView()
         public static readonly BindableProperty ElevationProperty = BindableProperty.Create(nameof(Elevation),
             typeof(float),
             typeof(XfxCardView),
-            default(float));
+            -1f);
 
         /// <summary>
         ///    Corner Radius. This is a bindable property. Default is 3.0f

From 4938c896435702e5252a98a26e40e2c81dff29d4 Mon Sep 17 00:00:00 2001
From: Chase Florell <chase.florell@gmail.com>
Date: Sat, 30 Dec 2017 15:29:10 -0800
Subject: [PATCH 3/3] [CF] Gesture Recognizer support on XfxCardView for
 Android. Fixes #42

---
 example/Xfx.Controls.Example/MainPage.xaml    |  11 +-
 .../Forms.Internals/GestureManager.cs         | 177 ++++++++++++++
 .../Forms.Internals/InnerGestureListener.cs   | 226 ++++++++++++++++++
 .../Forms.Internals/InnerScaleListener.cs     |  67 ++++++
 .../Forms.Internals/PanGestureHandler.cs      |  78 ++++++
 .../Forms.Internals/PinchGestureHandler.cs    |  69 ++++++
 .../Forms.Internals/TapGestureHandler.cs      |  60 +++++
 .../Renderers/XfxCardViewRendererDroid.cs     |  30 ++-
 .../Xfx.Controls.Droid.csproj                 |   7 +
 .../XfxVisualElementManager.cs                |  69 ++++++
 .../Renderers/XfxCardViewRendererTouch.cs     |   2 +-
 src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj  |   1 +
 .../XfxVisualElementManager.cs                |  54 ++---
 13 files changed, 809 insertions(+), 42 deletions(-)
 create mode 100644 src/Xfx.Controls.Droid/Forms.Internals/GestureManager.cs
 create mode 100644 src/Xfx.Controls.Droid/Forms.Internals/InnerGestureListener.cs
 create mode 100644 src/Xfx.Controls.Droid/Forms.Internals/InnerScaleListener.cs
 create mode 100644 src/Xfx.Controls.Droid/Forms.Internals/PanGestureHandler.cs
 create mode 100644 src/Xfx.Controls.Droid/Forms.Internals/PinchGestureHandler.cs
 create mode 100644 src/Xfx.Controls.Droid/Forms.Internals/TapGestureHandler.cs
 create mode 100644 src/Xfx.Controls.Droid/XfxVisualElementManager.cs

diff --git a/example/Xfx.Controls.Example/MainPage.xaml b/example/Xfx.Controls.Example/MainPage.xaml
index 4fc4b6d..ee50a48 100644
--- a/example/Xfx.Controls.Example/MainPage.xaml
+++ b/example/Xfx.Controls.Example/MainPage.xaml
@@ -19,9 +19,9 @@
                            HeightRequest="150"
                            HorizontalOptions="Fill"
                            Aspect="Fill" />
-                    <Label Margin="8">
+                    <Label Margin="10">
                         <Label.Text>
-                            Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse fringilla turpis turpis, id lobortis dolor vestibulum condimentum.
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse fringilla turpis turpis, id lobortis dolor vestibulum condimentum.
                         </Label.Text>
                     </Label>
                     <Button Text="Go to Main Page" Clicked="Button_OnClicked" Margin="8" />
@@ -34,11 +34,10 @@
                            HeightRequest="150"
                            HorizontalOptions="Fill" 
                            Aspect="Fill" />
-                    <Label Margin="8">
+                    <Label Margin="10">
                         <Label.Text>
-                            Tap this card to navigate to the next page
-                            
-                            Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse fringilla turpis turpis, id lobortis dolor vestibulum condimentum.
+Tap this card to navigate to the next page
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse fringilla turpis turpis, id lobortis dolor vestibulum condimentum.
                         </Label.Text>
                     </Label>
                 </StackLayout>
diff --git a/src/Xfx.Controls.Droid/Forms.Internals/GestureManager.cs b/src/Xfx.Controls.Droid/Forms.Internals/GestureManager.cs
new file mode 100644
index 0000000..c433b75
--- /dev/null
+++ b/src/Xfx.Controls.Droid/Forms.Internals/GestureManager.cs
@@ -0,0 +1,177 @@
+using System;
+using System.ComponentModel;
+using System.Linq;
+using Android.Support.V4.View;
+using Android.Views;
+using Xamarin.Forms;
+using Xamarin.Forms.Platform.Android;
+using View = Xamarin.Forms.View;
+
+namespace Xfx.Controls.Droid.Forms.Internals
+{
+    internal class GestureManager : IDisposable
+    {
+        IVisualElementRenderer _renderer;
+        readonly Lazy<GestureDetector> _tapAndPanDetector;
+        readonly Lazy<ScaleGestureDetector> _scaleDetector;
+
+        bool _disposed;
+        bool _inputTransparent;
+        bool _isEnabled;
+
+        VisualElement Element => _renderer?.Element;
+
+        View View => _renderer?.Element as View;
+
+        global::Android.Views.View Control => _renderer?.View;
+
+        public GestureManager(IVisualElementRenderer renderer)
+        {
+            _renderer = renderer;
+            _renderer.ElementChanged += OnElementChanged;
+
+            _tapAndPanDetector = new Lazy<GestureDetector>(InitializeTapAndPanDetector);
+            _scaleDetector = new Lazy<ScaleGestureDetector>(InitializeScaleDetector);
+        }
+
+        public bool OnTouchEvent(MotionEvent e)
+        {
+            if (Control == null)
+            {
+                return false;
+            }
+
+            if (!_isEnabled || _inputTransparent)
+            {
+                return false;
+            }
+
+            if (!DetectorsValid())
+            {
+                return false;
+            }
+
+            var eventConsumed = false;
+            if (ViewHasPinchGestures())
+            {
+                eventConsumed = _scaleDetector.Value.OnTouchEvent(e);
+            }
+
+            eventConsumed = _tapAndPanDetector.Value.OnTouchEvent(e) || eventConsumed;
+
+            return eventConsumed;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        bool DetectorsValid()
+        {
+            // Make sure we're not testing for gestures on old motion events after our 
+            // detectors have already been disposed
+
+            if (_scaleDetector.IsValueCreated && _scaleDetector.Value.Handle == IntPtr.Zero)
+            {
+                return false;
+            }
+
+            if (_tapAndPanDetector.IsValueCreated && _tapAndPanDetector.Value.Handle == IntPtr.Zero)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        GestureDetector InitializeTapAndPanDetector()
+        {
+            var context = Control.Context;
+            var listener = new InnerGestureListener(new TapGestureHandler(() => View),
+                new PanGestureHandler(() => View, context.FromPixels));
+
+            return new GestureDetector(context, listener);
+        }
+
+        ScaleGestureDetector InitializeScaleDetector()
+        {
+            var context = Control.Context;
+            var listener = new InnerScaleListener(new PinchGestureHandler(() => View), context.FromPixels);
+            var detector = new ScaleGestureDetector(context, listener, Control.Handler);
+            ScaleGestureDetectorCompat.SetQuickScaleEnabled(detector, true);
+
+            return detector;
+        }
+
+        bool ViewHasPinchGestures()
+        {
+            return View != null && View.GestureRecognizers.OfType<PinchGestureRecognizer>().Any();
+        }
+
+        void OnElementChanged(object sender, VisualElementChangedEventArgs e)
+        {
+            if (e.OldElement != null)
+            {
+                e.OldElement.PropertyChanged -= OnElementPropertyChanged;
+            }
+
+            if (e.NewElement != null)
+            {
+                e.NewElement.PropertyChanged += OnElementPropertyChanged;
+            }
+
+            UpdateInputTransparent();
+            UpdateIsEnabled();
+        }
+
+        void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName == VisualElement.InputTransparentProperty.PropertyName)
+                UpdateInputTransparent();
+            else if (e.PropertyName == VisualElement.IsEnabledProperty.PropertyName)
+                UpdateIsEnabled();
+        }
+
+        protected void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+
+            if (disposing)
+            {
+                if (Element != null)
+                {
+                    Element.PropertyChanged -= OnElementPropertyChanged;
+                }
+
+                _renderer = null;
+            }
+        }
+
+        void UpdateInputTransparent()
+        {
+            if (Element == null)
+            {
+                return;
+            }
+
+            _inputTransparent = Element.InputTransparent;
+        }
+
+        void UpdateIsEnabled()
+        {
+            if (Element == null)
+            {
+                return;
+            }
+
+            _isEnabled = Element.IsEnabled;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Forms.Internals/InnerGestureListener.cs b/src/Xfx.Controls.Droid/Forms.Internals/InnerGestureListener.cs
new file mode 100644
index 0000000..5787b03
--- /dev/null
+++ b/src/Xfx.Controls.Droid/Forms.Internals/InnerGestureListener.cs
@@ -0,0 +1,226 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Android.Runtime;
+using Android.Views;
+using Xamarin.Forms;
+using Object = Java.Lang.Object;
+
+namespace Xfx.Controls.Droid.Forms.Internals
+{
+    internal class InnerGestureListener : Object, GestureDetector.IOnGestureListener, GestureDetector.IOnDoubleTapListener
+    {
+        readonly TapGestureHandler _tapGestureHandler;
+        readonly PanGestureHandler _panGestureHandler;
+        bool _isScrolling;
+        float _lastX;
+        float _lastY;
+        bool _disposed;
+
+        Func<bool> _scrollCompleteDelegate;
+        Func<float, float, int, bool> _scrollDelegate;
+        Func<int, bool> _scrollStartedDelegate;
+        Func<int, bool> _tapDelegate;
+        Func<int, IEnumerable<TapGestureRecognizer>> _tapGestureRecognizers;
+
+        public InnerGestureListener(TapGestureHandler tapGestureHandler, PanGestureHandler panGestureHandler)
+        {
+            if (tapGestureHandler == null)
+            {
+                throw new ArgumentNullException(nameof(tapGestureHandler));
+            }
+
+            if (panGestureHandler == null)
+            {
+                throw new ArgumentNullException(nameof(panGestureHandler));
+            }
+
+            _tapGestureHandler = tapGestureHandler;
+            _panGestureHandler = panGestureHandler;
+
+            _tapDelegate = tapGestureHandler.OnTap;
+            _tapGestureRecognizers = tapGestureHandler.TapGestureRecognizers;
+            _scrollDelegate = panGestureHandler.OnPan;
+            _scrollStartedDelegate = panGestureHandler.OnPanStarted;
+            _scrollCompleteDelegate = panGestureHandler.OnPanComplete;
+        }
+
+        bool HasAnyGestures()
+        {
+            return _panGestureHandler.HasAnyGestures() || _tapGestureHandler.HasAnyGestures();
+        }
+
+        // This is needed because GestureRecognizer callbacks can be delayed several hundred milliseconds
+        // which can result in the need to resurrect this object if it has already been disposed. We dispose
+        // eagerly to allow easier garbage collection of the renderer
+        internal InnerGestureListener(IntPtr handle, JniHandleOwnership ownership) : base(handle, ownership)
+        {
+        }
+
+        bool GestureDetector.IOnDoubleTapListener.OnDoubleTap(MotionEvent e)
+        {
+            if (_disposed)
+                return false;
+
+            if (HasDoubleTapHandler())
+            {
+                return _tapDelegate(2);
+            }
+
+            if (HasSingleTapHandler())
+            {
+                // If we're registering double taps and we don't actually have a double-tap handler,
+                // but we _do_ have a single-tap handler, then we're really just seeing two singles in a row
+                // Fire off the delegate for the second single-tap (OnSingleTapUp already did the first one)
+                return _tapDelegate(1);
+            }
+
+            return false;
+        }
+
+        bool GestureDetector.IOnDoubleTapListener.OnDoubleTapEvent(MotionEvent e)
+        {
+            return false;
+        }
+
+        bool GestureDetector.IOnGestureListener.OnDown(MotionEvent e)
+        {
+            SetStartingPosition(e);
+
+            if (HasAnyGestures())
+            {
+                // If we have any gestures to listen for, we need to return true to show we're interested in the rest
+                // of the events.		
+                return true;
+            }
+
+            // Since we don't have any gestures we're listening for, we return false to show we're not interested
+            // and let parent controls have a whack at the events
+            return false;
+        }
+
+        bool GestureDetector.IOnGestureListener.OnFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
+        {
+            EndScrolling();
+            return false;
+        }
+
+        void GestureDetector.IOnGestureListener.OnLongPress(MotionEvent e)
+        {
+            SetStartingPosition(e);
+        }
+
+        bool GestureDetector.IOnGestureListener.OnScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
+        {
+            if (e1 == null || e2 == null)
+                return false;
+
+            SetStartingPosition(e1);
+
+            return StartScrolling(e2);
+        }
+
+        void GestureDetector.IOnGestureListener.OnShowPress(MotionEvent e)
+        {
+        }
+
+        bool GestureDetector.IOnGestureListener.OnSingleTapUp(MotionEvent e)
+        {
+            if (_disposed)
+                return false;
+
+            if (HasDoubleTapHandler())
+            {
+                // Because we have a handler for double-tap, we need to wait for
+                // OnSingleTapConfirmed (to verify it's really just a single tap) before running the delegate
+                return false;
+            }
+
+            // A single tap has occurred and there's no handler for double tap to worry about,
+            // so we can go ahead and run the delegate
+            return _tapDelegate(1);
+        }
+
+        bool GestureDetector.IOnDoubleTapListener.OnSingleTapConfirmed(MotionEvent e)
+        {
+            if (_disposed)
+                return false;
+
+            if (!HasDoubleTapHandler())
+            {
+                // We're not worried about double-tap, so OnSingleTapUp has already run the delegate
+                // there's nothing for us to do here
+                return false;
+            }
+
+            // Since there was a double-tap handler, we had to wait for OnSingleTapConfirmed;
+            // Now that we're sure it's a single tap, we can run the delegate
+            return _tapDelegate(1);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+
+            if (disposing)
+            {
+                _tapDelegate = null;
+                _tapGestureRecognizers = null;
+                _scrollDelegate = null;
+                _scrollStartedDelegate = null;
+                _scrollCompleteDelegate = null;
+            }
+
+            base.Dispose(disposing);
+        }
+
+        void SetStartingPosition(MotionEvent e1)
+        {
+            _lastX = e1.GetX();
+            _lastY = e1.GetY();
+        }
+
+        bool StartScrolling(MotionEvent e2)
+        {
+            if (_scrollDelegate == null)
+                return false;
+
+            if (!_isScrolling && _scrollStartedDelegate != null)
+                _scrollStartedDelegate(e2.PointerCount);
+
+            _isScrolling = true;
+
+            float totalX = e2.GetX() - _lastX;
+            float totalY = e2.GetY() - _lastY;
+
+            return _scrollDelegate(totalX, totalY, e2.PointerCount);
+        }
+
+        void EndScrolling()
+        {
+            if (_isScrolling && _scrollCompleteDelegate != null)
+                _scrollCompleteDelegate();
+
+            _isScrolling = false;
+        }
+
+        bool HasDoubleTapHandler()
+        {
+            if (_tapGestureRecognizers == null)
+                return false;
+            return _tapGestureRecognizers(2).Any();
+        }
+
+        bool HasSingleTapHandler()
+        {
+            if (_tapGestureRecognizers == null)
+                return false;
+            return _tapGestureRecognizers(1).Any();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Forms.Internals/InnerScaleListener.cs b/src/Xfx.Controls.Droid/Forms.Internals/InnerScaleListener.cs
new file mode 100644
index 0000000..b884a4a
--- /dev/null
+++ b/src/Xfx.Controls.Droid/Forms.Internals/InnerScaleListener.cs
@@ -0,0 +1,67 @@
+using System;
+using Android.Runtime;
+using Android.Views;
+using Xamarin.Forms;
+
+namespace Xfx.Controls.Droid.Forms.Internals
+{
+    internal class InnerScaleListener : ScaleGestureDetector.SimpleOnScaleGestureListener
+    {
+        Func<float, Point, bool> _pinchDelegate;
+        Action _pinchEndedDelegate;
+        readonly Func<double, double> _fromPixels;
+        Func<Point, bool> _pinchStartedDelegate;
+
+        public InnerScaleListener(PinchGestureHandler pinchGestureHandler, Func<double, double> fromPixels)
+        {
+            if (pinchGestureHandler == null)
+            {
+                throw new ArgumentNullException(nameof(pinchGestureHandler));
+            }
+
+            _pinchDelegate = pinchGestureHandler.OnPinch;
+            _pinchStartedDelegate = pinchGestureHandler.OnPinchStarted;
+            _pinchEndedDelegate = pinchGestureHandler.OnPinchEnded;
+            _fromPixels = fromPixels;
+        }
+
+        // This is needed because GestureRecognizer callbacks can be delayed several hundred milliseconds
+        // which can result in the need to resurect this object if it has already been disposed. We dispose
+        // eagerly to allow easier garbage collection of the renderer
+        internal InnerScaleListener(IntPtr handle, JniHandleOwnership ownership) : base(handle, ownership)
+        {
+        }
+
+        public override bool OnScale(ScaleGestureDetector detector)
+        {
+            float cur = detector.CurrentSpan;
+            float last = detector.PreviousSpan;
+
+            if (Math.Abs(cur - last) < 10)
+                return false;
+
+            return _pinchDelegate(detector.ScaleFactor, new Point(_fromPixels(detector.FocusX), _fromPixels(detector.FocusY)));
+        }
+
+        public override bool OnScaleBegin(ScaleGestureDetector detector)
+        {
+            return _pinchStartedDelegate(new Point(_fromPixels(detector.FocusX), _fromPixels(detector.FocusY)));
+        }
+
+        public override void OnScaleEnd(ScaleGestureDetector detector)
+        {
+            _pinchEndedDelegate();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _pinchDelegate = null;
+                _pinchStartedDelegate = null;
+                _pinchEndedDelegate = null;
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Forms.Internals/PanGestureHandler.cs b/src/Xfx.Controls.Droid/Forms.Internals/PanGestureHandler.cs
new file mode 100644
index 0000000..0032c37
--- /dev/null
+++ b/src/Xfx.Controls.Droid/Forms.Internals/PanGestureHandler.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Linq;
+using Xamarin.Forms;
+using Xamarin.Forms.Internals;
+
+namespace Xfx.Controls.Droid.Forms.Internals
+{
+    internal class PanGestureHandler
+    {
+        readonly Func<double, double> _pixelTranslation;
+
+        public PanGestureHandler(Func<View> getView, Func<double, double> pixelTranslation)
+        {
+            _pixelTranslation = pixelTranslation;
+            GetView = getView;
+        }
+
+        Func<View> GetView { get; }
+
+        public bool OnPan(float x, float y, int pointerCount)
+        {
+            View view = GetView();
+
+            if (view == null)
+                return false;
+
+            var result = false;
+            foreach (PanGestureRecognizer panGesture in
+                view.GestureRecognizers.GetGesturesFor<PanGestureRecognizer>(g => g.TouchPoints == pointerCount))
+            {
+                ((IPanGestureController)panGesture).SendPan(view, _pixelTranslation(x), _pixelTranslation(y), Application.Current.PanGestureId);
+                result = true;
+            }
+
+            return result;
+        }
+
+        public bool OnPanComplete()
+        {
+            View view = GetView();
+
+            if (view == null)
+                return false;
+
+            var result = false;
+            foreach (PanGestureRecognizer panGesture in view.GestureRecognizers.GetGesturesFor<PanGestureRecognizer>())
+            {
+                ((IPanGestureController)panGesture).SendPanCompleted(view, Application.Current.PanGestureId);
+                result = true;
+            }
+            Application.Current.PanGestureId++;
+            return result;
+        }
+
+        public bool OnPanStarted(int pointerCount)
+        {
+            View view = GetView();
+
+            if (view == null)
+                return false;
+
+            var result = false;
+            foreach (PanGestureRecognizer panGesture in
+                view.GestureRecognizers.GetGesturesFor<PanGestureRecognizer>(g => g.TouchPoints == pointerCount))
+            {
+                ((IPanGestureController)panGesture).SendPanStarted(view, Application.Current.PanGestureId);
+                result = true;
+            }
+            return result;
+        }
+
+        public bool HasAnyGestures()
+        {
+            var view = GetView();
+            return view != null && view.GestureRecognizers.OfType<PanGestureRecognizer>().Any();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Forms.Internals/PinchGestureHandler.cs b/src/Xfx.Controls.Droid/Forms.Internals/PinchGestureHandler.cs
new file mode 100644
index 0000000..41d5949
--- /dev/null
+++ b/src/Xfx.Controls.Droid/Forms.Internals/PinchGestureHandler.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using Xamarin.Forms;
+
+namespace Xfx.Controls.Droid.Forms.Internals
+{
+    internal class PinchGestureHandler
+    {
+        double _pinchStartingScale = 1;
+
+        public PinchGestureHandler(Func<View> getView)
+        {
+            GetView = getView;
+        }
+
+        Func<View> GetView { get; }
+
+        // A View can have at most one pinch gesture, so we just need to look for one (or none)
+        PinchGestureRecognizer PinchGesture => GetView()?.GestureRecognizers.OfType<PinchGestureRecognizer>()
+            .FirstOrDefault();
+
+        public bool OnPinch(float scale, Point scalePoint)
+        {
+            View view = GetView();
+
+            if (view == null)
+                return false;
+
+            PinchGestureRecognizer pinchGesture = PinchGesture;
+            if (pinchGesture == null)
+                return true;
+
+            var scalePointTransformed = new Point(scalePoint.X / view.Width, scalePoint.Y / view.Height);
+            pinchGesture.SendPinch(view, 1 + (scale - 1) * _pinchStartingScale, scalePointTransformed);
+
+            return true;
+        }
+
+        public void OnPinchEnded()
+        {
+            View view = GetView();
+
+            if (view == null)
+                return;
+
+            PinchGestureRecognizer pinchGesture = PinchGesture;
+            pinchGesture?.SendPinchEnded(view);
+        }
+
+        public bool OnPinchStarted(Point scalePoint)
+        {
+            View view = GetView();
+
+            if (view == null)
+                return false;
+
+            PinchGestureRecognizer pinchGesture = PinchGesture;
+            if (pinchGesture == null)
+                return false;
+
+            _pinchStartingScale = view.Scale;
+
+            var scalePointTransformed = new Point(scalePoint.X / view.Width, scalePoint.Y / view.Height);
+
+            pinchGesture.SendPinchStarted(view, scalePointTransformed);
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Forms.Internals/TapGestureHandler.cs b/src/Xfx.Controls.Droid/Forms.Internals/TapGestureHandler.cs
new file mode 100644
index 0000000..84df314
--- /dev/null
+++ b/src/Xfx.Controls.Droid/Forms.Internals/TapGestureHandler.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xamarin.Forms;
+using Xamarin.Forms.Internals;
+
+namespace Xfx.Controls.Droid.Forms.Internals
+{
+    internal class TapGestureHandler
+    {
+        public TapGestureHandler(Func<View> getView)
+        {
+            GetView = getView;
+        }
+
+        Func<View> GetView { get; }
+
+        public void OnSingleClick()
+        {
+            // only handle click if we don't have double tap registered
+            if (TapGestureRecognizers(2).Any())
+                return;
+
+            OnTap(1);
+        }
+
+        public bool OnTap(int count)
+        {
+            View view = GetView();
+
+            if (view == null)
+                return false;
+
+            IEnumerable<TapGestureRecognizer> gestureRecognizers = TapGestureRecognizers(count);
+            var result = false;
+            foreach (TapGestureRecognizer gestureRecognizer in gestureRecognizers)
+            {
+                gestureRecognizer.SendTapped(view);
+                result = true;
+            }
+
+            return result;
+        }
+
+        public bool HasAnyGestures()
+        {
+            var view = GetView();
+            return view != null && view.GestureRecognizers.OfType<TapGestureRecognizer>().Any();
+        }
+
+        public IEnumerable<TapGestureRecognizer> TapGestureRecognizers(int count)
+        {
+            View view = GetView();
+            if (view == null)
+                return Enumerable.Empty<TapGestureRecognizer>();
+
+            return view.GestureRecognizers.GetGesturesFor<TapGestureRecognizer>(recognizer => recognizer.NumberOfTapsRequired == count);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs b/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs
index d6d16f4..ea5314b 100644
--- a/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs
+++ b/src/Xfx.Controls.Droid/Renderers/XfxCardViewRendererDroid.cs
@@ -7,6 +7,8 @@
 using Xfx;
 using Xfx.Controls.Droid.Renderers;
 using AContext = Android.Content.Context;
+using AView = Android.Views.View;
+
 [assembly: ExportRenderer(typeof(XfxCardView), typeof(XfxCardViewRendererDroid))]
 
 namespace Xfx.Controls.Droid.Renderers
@@ -15,6 +17,7 @@ public class XfxCardViewRendererDroid : CardView, IVisualElementRenderer
     {
         private float _defaultElevation;
         private float _defaultCornerRadius;
+        private XfxVisualElementManager _visualElementManager;
 
         public XfxCardViewRendererDroid(AContext context) : base(context)
         {
@@ -22,14 +25,13 @@ public XfxCardViewRendererDroid(AContext context) : base(context)
 
         [Obsolete("ViewGroup is obsolete as of version 2.3.5. Please use View instead.")]
         public ViewGroup ViewGroup => this;
-        public Android.Views.View View => this;
-        public VisualElementPackager Packager { get; private set; }
-        public VisualElementTracker Tracker { get; private set; }
+        public AView View => this;
+        VisualElementTracker IVisualElementRenderer.Tracker => _visualElementManager.Tracker;
         public VisualElement Element { get; private set; }
         public event EventHandler<VisualElementChangedEventArgs> ElementChanged;
         public event EventHandler<PropertyChangedEventArgs> ElementPropertyChanged;
         public void SetLabelFor(int? id) { }
-        public void UpdateLayout() => Tracker?.UpdateLayout();
+        public void UpdateLayout() => _visualElementManager?.UpdateLayout();
         protected XfxCardView CardView => (XfxCardView)Element;
         protected virtual void OnElementChanged(object sender, VisualElementChangedEventArgs args) { }
         protected virtual void OnElementPropertyChanged(object sender, PropertyChangedEventArgs args) { }
@@ -50,9 +52,8 @@ void IVisualElementRenderer.SetElement(VisualElement element)
 
             //sizes to match the forms view
             //updates properties, handles visual element properties
-            Tracker = new VisualElementTracker(this);
-            Packager = new VisualElementPackager(this);
-            Packager.Load();
+            _visualElementManager = new XfxVisualElementManager();
+            _visualElementManager.Init(this);
             UseCompatPadding = true;
 
             _defaultElevation = Elevation;
@@ -64,6 +65,8 @@ void IVisualElementRenderer.SetElement(VisualElement element)
             RaiseElementChanged(new VisualElementChangedEventArgs(oldElement, Element));
         }
 
+
+
         public SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint)
         {
             View.Measure(widthConstraint, heightConstraint);
@@ -73,7 +76,7 @@ public SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint)
         private void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
         {
             if (e.PropertyName == ContentView.ContentProperty.PropertyName)
-                Tracker.UpdateLayout();
+                ((IVisualElementRenderer) this).Tracker.UpdateLayout();
             else if (e.PropertyName == Xamarin.Forms.Layout.PaddingProperty.PropertyName)
                 SetContentPadding();
             else if (e.PropertyName == XfxCardView.CornerRadiusProperty.PropertyName)
@@ -99,10 +102,21 @@ private void RaiseElementChanged(VisualElementChangedEventArgs args)
             OnElementChanged(this, args);
         }
 
+        public override bool OnTouchEvent(MotionEvent e)
+        {
+            return _visualElementManager.OnTouchEvent(e) || base.OnTouchEvent(e);
+        }
+
         private void RaiseElementPropertyChanged(PropertyChangedEventArgs args)
         {
             ElementPropertyChanged?.Invoke(this, args);
             OnElementPropertyChanged(this, args);
         }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            _visualElementManager?.Dispose();
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Xfx.Controls.Droid/Xfx.Controls.Droid.csproj b/src/Xfx.Controls.Droid/Xfx.Controls.Droid.csproj
index 0ea69ee..3102a42 100644
--- a/src/Xfx.Controls.Droid/Xfx.Controls.Droid.csproj
+++ b/src/Xfx.Controls.Droid/Xfx.Controls.Droid.csproj
@@ -122,6 +122,13 @@
   <ItemGroup>
     <Compile Include="Extensions\CollectionExtensions.cs" />
     <Compile Include="Renderers\XfxCardViewRendererDroid.cs" />
+    <Compile Include="Forms.Internals\InnerScaleListener.cs" />
+    <Compile Include="Forms.Internals\PinchGestureHandler.cs" />
+    <Compile Include="Forms.Internals\PanGestureHandler.cs" />
+    <Compile Include="Forms.Internals\TapGestureHandler.cs" />
+    <Compile Include="Forms.Internals\InnerGestureListener.cs" />
+    <Compile Include="Forms.Internals\GestureManager.cs" />
+    <Compile Include="XfxVisualElementManager.cs" />
     <Compile Include="XfxComboBox\XfxComboBoxArrayAdapter.cs" />
     <Compile Include="Extensions\FontExtensions.cs" />
     <Compile Include="Extensions\KeyboardExtensions.cs" />
diff --git a/src/Xfx.Controls.Droid/XfxVisualElementManager.cs b/src/Xfx.Controls.Droid/XfxVisualElementManager.cs
new file mode 100644
index 0000000..9304980
--- /dev/null
+++ b/src/Xfx.Controls.Droid/XfxVisualElementManager.cs
@@ -0,0 +1,69 @@
+using System;
+using Android.Views;
+using Xamarin.Forms.Platform.Android;
+using Xfx.Controls.Droid.Forms.Internals;
+
+namespace Xfx.Controls.Droid
+{
+    public class XfxVisualElementManager : IDisposable
+    {
+        private VisualElementPackager _packager;
+        private VisualElementRendererFlags _flags;
+        private VisualElementTracker _tracker;
+        private GestureManager _gestureManager;
+
+        public bool AutoPackage => (_flags & VisualElementRendererFlags.AutoPackage) != 0;
+
+        public bool AutoTrack => (_flags & VisualElementRendererFlags.AutoTrack) != 0;
+
+        protected bool IsDisposed => _flags.HasFlag(VisualElementRendererFlags.Disposed);
+        public VisualElementTracker Tracker => _tracker;
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (IsDisposed || !disposing)
+            {
+                return;
+            }
+
+            _flags |= VisualElementRendererFlags.Disposed;
+
+            if (_tracker != null)
+            {
+                _tracker.Dispose();
+                _tracker = null;
+            }
+            if (_packager != null)
+            {
+                _packager.Dispose();
+                _packager = null;
+            }
+        }
+
+        public void Init(IVisualElementRenderer renderer, VisualElementRendererFlags flags = VisualElementRendererFlags.AutoPackage|VisualElementRendererFlags.AutoTrack)
+        {
+
+            _flags = flags;
+            _packager = new VisualElementPackager(renderer);
+            _tracker = new VisualElementTracker(renderer);
+            _gestureManager = new GestureManager(renderer);
+
+            if (AutoPackage)
+                _packager?.Load();
+        }
+
+        public void UpdateLayout()
+        {
+            if(AutoTrack)
+                _tracker?.UpdateLayout();
+        }
+
+        public bool OnTouchEvent(MotionEvent motionEvent) => _gestureManager.OnTouchEvent(motionEvent);
+    }
+}
\ No newline at end of file
diff --git a/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs b/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs
index 784b16a..a9b3451 100644
--- a/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs
+++ b/src/Xfx.Controls.iOS/Renderers/XfxCardViewRendererTouch.cs
@@ -58,7 +58,7 @@ protected virtual void OnElementPropertyChanged(object sender, PropertyChangedEv
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
-            _xfxVisualElementManager.Dispose();
+            _xfxVisualElementManager?.Dispose();
         }
 
         private void HandlePropertyChanged(object sender, PropertyChangedEventArgs e)
diff --git a/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj b/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj
index 3bc3374..81712a9 100644
--- a/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj
+++ b/src/Xfx.Controls.iOS/Xfx.Controls.iOS.csproj
@@ -100,6 +100,7 @@
     <Compile Include="Extensions\FontExtensions.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Extensions\UIViewExtensions.cs" />
+    <Compile Include="InvalidRendererException.cs" />
     <Compile Include="XfxVisualElementManager.cs" />
     <Compile Include="Renderers\XfxCardViewRendererTouch.cs" />
     <Compile Include="Renderers\XfxEntryRendererTouch.cs" />
diff --git a/src/Xfx.Controls.iOS/XfxVisualElementManager.cs b/src/Xfx.Controls.iOS/XfxVisualElementManager.cs
index b2507a8..f1e91d3 100644
--- a/src/Xfx.Controls.iOS/XfxVisualElementManager.cs
+++ b/src/Xfx.Controls.iOS/XfxVisualElementManager.cs
@@ -4,39 +4,37 @@
 
 namespace Xfx.Controls.iOS
 {
+    /// <summary>
+    /// Used to add Gesture Recognizers and other Forms features to a Renderer.
+    /// </summary>
     public class XfxVisualElementManager : IDisposable
     {
         private EventTracker _events;
-        private VisualElementRendererFlags _flags = VisualElementRendererFlags.AutoPackage | VisualElementRendererFlags.AutoTrack;
+        private VisualElementRendererFlags _flags;
         private VisualElementPackager _packager;
         private VisualElementTracker _tracker;
 
-        public bool AutoPackage
+        public bool AutoPackage => (_flags & VisualElementRendererFlags.AutoPackage) != 0;
+
+        public bool AutoTrack => (_flags & VisualElementRendererFlags.AutoTrack) != 0;
+
+        protected bool IsDisposed => _flags.HasFlag(VisualElementRendererFlags.Disposed);
+
+        public void Dispose()
         {
-            get => (_flags & VisualElementRendererFlags.AutoPackage) != 0;
-            set
-            {
-                if (value)
-                    _flags |= VisualElementRendererFlags.AutoPackage;
-                else
-                    _flags &= ~VisualElementRendererFlags.AutoPackage;
-            }
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
-        public bool AutoTrack
+        protected virtual void Dispose(bool disposing)
         {
-            get => (_flags & VisualElementRendererFlags.AutoTrack) != 0;
-            set
+            if (IsDisposed || !disposing)
             {
-                if (value)
-                    _flags |= VisualElementRendererFlags.AutoTrack;
-                else
-                    _flags &= ~VisualElementRendererFlags.AutoTrack;
+                return;
             }
-        }
 
-        public void Dispose()
-        {
+            _flags |= VisualElementRendererFlags.Disposed;
+
             if (_events != null)
             {
                 _events.Dispose();
@@ -54,22 +52,24 @@ public void Dispose()
             }
         }
 
-        public void Init(IVisualElementRenderer renderer)
+        public void Init(IVisualElementRenderer renderer, VisualElementRendererFlags flags = VisualElementRendererFlags.AutoPackage | VisualElementRendererFlags.AutoTrack)
         {
-            _tracker = new VisualElementTracker(renderer);
-            _tracker.NativeControlUpdated += OnNativeControlUpdated;
-
+            _flags = flags;
             _packager = new VisualElementPackager(renderer);
             _events = new EventTracker(renderer);
-
-            if (AutoPackage)
-                _packager?.Load();
+            _tracker = new VisualElementTracker(renderer);
+            _tracker.NativeControlUpdated += OnNativeControlUpdated;
 
             if (AutoTrack)
+            {
                 if (renderer is UIView uiView)
                     _events.LoadEvents(uiView);
                 else
                     throw new InvalidRendererException("IVisualElementRenderer must be of type 'UIView'");
+            }
+
+            if (AutoPackage)
+                _packager?.Load();
         }
 
         protected virtual void UpdateNativeWidget()