From 927cc8f24e45ad690595763c5beb28ef2ed32ee9 Mon Sep 17 00:00:00 2001
From: Enis Necipoglu <iletisim@enisnecipoglu.com>
Date: Sun, 3 Mar 2019 23:50:25 -0800
Subject: [PATCH] iOS suggestions work (#83)

---
 InputKit/InputKit.csproj                      |   5 +-
 .../Droid/AutoCompleteViewRenderer.cs         | 219 ++++++++++++++
 .../Platforms/iOS/AutoCompleteViewRenderer.cs | 122 ++++++++
 .../iOS/Controls/MbAutoCompleteTableView.cs   |  28 ++
 .../iOS/Controls/MbAutoCompleteTextField.cs   | 183 ++++++++++++
 InputKit/Platforms/iOS/Helpers/Extensions.cs  | 275 ++++++++++++++++++
 .../MbAutoCompleteDefaultDataSource.cs        |  31 ++
 .../iOS/Helpers/MbAutoCompleteViewSource.cs   |  40 +++
 InputKit/Shared/Controls/AdvancedEntry.cs     |  26 +-
 InputKit/Shared/Controls/AutoCompleteEntry.cs |  45 +++
 InputKit/Shared/Controls/AutoCompleteView.cs  | 119 ++++++++
 InputKit/Shared/Helpers/StringExtensions.cs   |  12 +
 .../Sample.InputKit.Android.csproj            |   2 +
 .../Sample.InputKit.iOS.csproj                |   8 +
 Sample.InputKit/Sample.InputKit/MainPage.xaml |   2 +
 .../Sample.InputKit/MainPage.xaml.cs          |  13 +
 .../Sample.InputKit/Sample.InputKit.csproj    |   4 +
 .../Views/AutoCompleteEntriesPage.xaml        |  17 ++
 .../Views/AutoCompleteEntriesPage.xaml.cs     |  39 +++
 19 files changed, 1180 insertions(+), 10 deletions(-)
 create mode 100644 InputKit/Platforms/Droid/AutoCompleteViewRenderer.cs
 create mode 100644 InputKit/Platforms/iOS/AutoCompleteViewRenderer.cs
 create mode 100644 InputKit/Platforms/iOS/Controls/MbAutoCompleteTableView.cs
 create mode 100644 InputKit/Platforms/iOS/Controls/MbAutoCompleteTextField.cs
 create mode 100644 InputKit/Platforms/iOS/Helpers/Extensions.cs
 create mode 100644 InputKit/Platforms/iOS/Helpers/MbAutoCompleteDefaultDataSource.cs
 create mode 100644 InputKit/Platforms/iOS/Helpers/MbAutoCompleteViewSource.cs
 create mode 100644 InputKit/Shared/Controls/AutoCompleteEntry.cs
 create mode 100644 InputKit/Shared/Controls/AutoCompleteView.cs
 create mode 100644 InputKit/Shared/Helpers/StringExtensions.cs
 create mode 100644 Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml
 create mode 100644 Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml.cs

diff --git a/InputKit/InputKit.csproj b/InputKit/InputKit.csproj
index 8d0a030..5fcdcdd 100644
--- a/InputKit/InputKit.csproj
+++ b/InputKit/InputKit.csproj
@@ -14,7 +14,7 @@
     <PackageVersion>1.0.0.0</PackageVersion>
     <PackOnBuild>true</PackOnBuild>
     <NeutralLanguage>en</NeutralLanguage>
-    <LangVersion>7.1</LangVersion>
+    <LangVersion>7.3</LangVersion>
     <DefineConstants>$(DefineConstants);</DefineConstants>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <GenerateDocumentationFile Condition=" '$(Configuration)' == 'Release' ">true</GenerateDocumentationFile>
@@ -124,8 +124,7 @@
     <EmbeddedResource Include="Shared\Resources\**\*.png" />
     <EmbeddedResource Include="Shared\Resources\**\*.jpg" />
   </ItemGroup>
-  
-  
+
   <!--
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0' ">
     <Compile Include="Platforms\DotNet\**\*.cs" />
diff --git a/InputKit/Platforms/Droid/AutoCompleteViewRenderer.cs b/InputKit/Platforms/Droid/AutoCompleteViewRenderer.cs
new file mode 100644
index 0000000..7047575
--- /dev/null
+++ b/InputKit/Platforms/Droid/AutoCompleteViewRenderer.cs
@@ -0,0 +1,219 @@
+using System.ComponentModel;
+using Android.Content;
+using Android.Content.Res;
+using Android.Support.Design.Widget;
+using Android.Support.V4.View;
+using Android.Support.V7.Widget;
+using Android.Text;
+using Android.Text.Method;
+using Android.Util;
+using Android.Views;
+using Android.Views.InputMethods;
+using Android.Widget;
+using Java.Lang;
+using Xamarin.Forms;
+using Xamarin.Forms.Platform.Android;
+using Application = Android.App.Application;
+using Color = Xamarin.Forms.Color;
+using AColor = Android.Graphics.Color;
+using FormsAppCompat = Xamarin.Forms.Platform.Android.AppCompat;
+using Plugin.InputKit.Shared.Controls;
+using Plugin.InputKit.Platforms.Droid;
+using System.Collections.Specialized;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using System.Collections;
+using Android.Graphics.Drawables;
+
+[assembly: ExportRenderer(typeof(AutoCompleteView), typeof(AutoCompleteViewRenderer))]
+namespace Plugin.InputKit.Platforms.Droid
+{
+    public class AutoCompleteViewRenderer : FormsAppCompat.ViewRenderer<AutoCompleteView, TextInputLayout>
+    {
+        public AutoCompleteViewRenderer(Context context) : base(context)
+        {
+        }
+
+        private AppCompatAutoCompleteTextView AutoComplete => Control?.EditText as AppCompatAutoCompleteTextView;
+
+        protected override TextInputLayout CreateNativeControl()
+        {
+            var textInputLayout = new TextInputLayout(Context);
+            var autoComplete = new AppCompatAutoCompleteTextView(Context)
+            {
+                BackgroundTintList = ColorStateList.ValueOf(GetPlaceholderColor())
+            };
+
+            GradientDrawable gd = new GradientDrawable();
+            gd.SetColor(global::Android.Graphics.Color.Transparent);
+            autoComplete.SetBackground(gd);
+
+            textInputLayout.AddView(autoComplete);
+            return textInputLayout;
+        }
+
+        protected override void OnElementChanged(ElementChangedEventArgs<AutoCompleteView> e)
+        {
+            base.OnElementChanged(e);
+            if (e.OldElement != null)
+            {
+                // unsubscribe
+                AutoComplete.ItemClick -= AutoCompleteOnItemSelected;
+                var elm = e.OldElement;
+                elm.CollectionChanged -= ItemsSourceCollectionChanged;
+            }
+
+            if (e.NewElement != null)
+            {
+                SetNativeControl(CreateNativeControl());
+                // subscribe
+                SetItemsSource();
+                SetThreshold();
+                KillPassword();
+                AutoComplete.ItemClick += AutoCompleteOnItemSelected;
+                var elm = e.NewElement;
+                elm.CollectionChanged += ItemsSourceCollectionChanged;
+            }
+        }
+
+        protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            base.OnElementPropertyChanged(sender, e);
+
+            if (e.PropertyName == Entry.IsPasswordProperty.PropertyName)
+                KillPassword();
+            if (e.PropertyName == AutoCompleteView.ItemsSourceProperty.PropertyName)
+                SetItemsSource();
+            else if (e.PropertyName == AutoCompleteView.ThresholdProperty.PropertyName)
+                SetThreshold();
+        }
+
+        private void AutoCompleteOnItemSelected(object sender, AdapterView.ItemClickEventArgs args)
+        {
+            var view = (AutoCompleteTextView)sender;
+            var selectedItemArgs = new SelectedItemChangedEventArgs(view.Text);
+            var element = (AutoCompleteView)Element;
+            element.OnItemSelectedInternal(Element, selectedItemArgs);
+        }
+
+        private void ItemsSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs notifyCollectionChangedEventArgs)
+        {
+            var element = (AutoCompleteView)Element;
+            ResetAdapter(element);
+        }
+
+        private void KillPassword()
+        {
+            if (Element.IsPassword)
+                throw new NotImplementedException("Cannot set IsPassword on a AutoComplete");
+        }
+
+        private void ResetAdapter(AutoCompleteView element)
+        {
+            var adapter = new BoxArrayAdapter(Context,
+                Android.Resource.Layout.SimpleDropDownItem1Line,
+                element.ItemsSource.ToList(),
+                element.SortingAlgorithm);
+            AutoComplete.Adapter = adapter;
+            adapter.NotifyDataSetChanged();
+        }
+
+        private void SetItemsSource()
+        {
+            var element = (AutoCompleteView)Element;
+            if (element.ItemsSource == null) return;
+
+            ResetAdapter(element);
+        }
+
+        private void SetThreshold()
+        {
+            var element = (AutoCompleteView)Element;
+            AutoComplete.Threshold = element.Threshold;
+        }
+
+        #region Section 2
+        protected AColor GetPlaceholderColor() => Element.PlaceholderColor.ToAndroid(Color.FromHex("#80000000"));
+        #endregion
+    }
+
+    internal class BoxArrayAdapter : ArrayAdapter
+    {
+        private readonly IList<string> _objects;
+        private readonly Func<string, ICollection<string>, ICollection<string>> _sortingAlgorithm;
+
+        public BoxArrayAdapter(
+            Context context,
+            int textViewResourceId,
+            List<string> objects,
+            Func<string, ICollection<string>, ICollection<string>> sortingAlgorithm) : base(context, textViewResourceId, objects)
+        {
+            _objects = objects;
+            _sortingAlgorithm = sortingAlgorithm;
+        }
+
+        public override Filter Filter
+        {
+            get
+            {
+                return new CustomFilter(_sortingAlgorithm) { Adapter = this, Originals = _objects };
+            }
+        }
+    }
+
+    internal class CustomFilter : Filter
+    {
+        private readonly Func<string, ICollection<string>, ICollection<string>> _sortingAlgorithm;
+
+        public CustomFilter(Func<string, ICollection<string>, ICollection<string>> sortingAlgorithm)
+        {
+            _sortingAlgorithm = sortingAlgorithm;
+        }
+
+        public BoxArrayAdapter Adapter { private get; set; }
+        public IList<string> Originals { get; set; }
+
+        protected override FilterResults PerformFiltering(ICharSequence constraint)
+        {
+            var results = new FilterResults();
+            if (constraint == null || constraint.Length() == 0)
+            {
+                results.Values = new Java.Util.ArrayList(Originals.ToList());
+                results.Count = Originals.Count;
+            }
+            else
+            {
+                var values = new Java.Util.ArrayList();
+                var sorted = _sortingAlgorithm(constraint.ToString(), Originals).ToList();
+
+                for (var index = 0; index < sorted.Count; index++)
+                {
+                    var item = sorted[index];
+                    values.Add(item);
+                }
+
+                results.Values = values;
+                results.Count = sorted.Count;
+            }
+
+            return results;
+        }
+
+        protected override void PublishResults(ICharSequence constraint, FilterResults results)
+        {
+            if (results.Count == 0)
+                Adapter.NotifyDataSetInvalidated();
+            else
+            {
+                Adapter.Clear();
+                var vals = (Java.Util.ArrayList)results.Values;
+                foreach (var val in vals.ToArray())
+                {
+                    Adapter.Add(val);
+                }
+                Adapter.NotifyDataSetChanged();
+            }
+        }
+    }
+}
diff --git a/InputKit/Platforms/iOS/AutoCompleteViewRenderer.cs b/InputKit/Platforms/iOS/AutoCompleteViewRenderer.cs
new file mode 100644
index 0000000..b305213
--- /dev/null
+++ b/InputKit/Platforms/iOS/AutoCompleteViewRenderer.cs
@@ -0,0 +1,122 @@
+using CoreGraphics;
+using Plugin.InputKit.Platforms.iOS;
+using Plugin.InputKit.Platforms.iOS.Controls;
+using Plugin.InputKit.Platforms.iOS.Helpers;
+using Plugin.InputKit.Shared.Controls;
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using UIKit;
+using Xamarin.Forms;
+using Xamarin.Forms.Platform.iOS;
+
+[assembly: ExportRenderer(typeof(AutoCompleteView), typeof(AutoCompleteViewRenderer))]
+namespace Plugin.InputKit.Platforms.iOS
+{
+    public class AutoCompleteViewRenderer : ViewRenderer<AutoCompleteView, UITextField>
+    {
+        private MbAutoCompleteTextField NativeControl => (MbAutoCompleteTextField)Control;
+        private AutoCompleteView AutoCompleteEntry => (AutoCompleteView)Element;
+
+        public AutoCompleteViewRenderer()
+        {
+            // ReSharper disable once VirtualMemberCallInContructor
+            Frame = new RectangleF(0, 20, 320, 40);
+        }
+
+        protected override UITextField CreateNativeControl()
+        {
+            var element = (AutoCompleteView)Element;
+            var view = new MbAutoCompleteTextField
+            {
+                AutoCompleteViewSource = new MbAutoCompleteDefaultDataSource(),
+                SortingAlgorithm = element.SortingAlgorithm
+            };
+            view.AutoCompleteViewSource.Selected += AutoCompleteViewSourceOnSelected;
+            return view;
+        }
+        public override void Draw(CGRect rect)
+        {
+            base.Draw(rect);
+            var scrollView = GetParentScrollView(Control);
+            var ctrl = UIApplication.SharedApplication.GetTopViewController();
+            NativeControl.Draw(ctrl, Layer, scrollView);
+        }
+
+        protected override void OnElementChanged(ElementChangedEventArgs<AutoCompleteView> e)
+        {
+            base.OnElementChanged(e);
+            if (e.OldElement != null)
+            {
+                // unsubscribe
+                NativeControl.AutoCompleteViewSource.Selected -= AutoCompleteViewSourceOnSelected;
+                var elm = (AutoCompleteView)e.OldElement;
+                elm.CollectionChanged -= ItemsSourceCollectionChanged;
+            }
+
+            if (e.NewElement != null)
+            {
+                SetNativeControl(CreateNativeControl());
+                SetItemsSource();
+                SetThreshold();
+                KillPassword();
+
+                var elm = (AutoCompleteView)e.NewElement;
+                elm.CollectionChanged += ItemsSourceCollectionChanged;
+            }
+        }
+
+        protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            base.OnElementPropertyChanged(sender, e);
+
+            if (e.PropertyName == Entry.IsPasswordProperty.PropertyName)
+                KillPassword();
+            if (e.PropertyName == AutoCompleteView.ItemsSourceProperty.PropertyName)
+                SetItemsSource();
+            else if (e.PropertyName == AutoCompleteView.ThresholdProperty.PropertyName)
+                SetThreshold();
+        }
+
+        private void SetThreshold()
+        {
+            NativeControl.Threshold = AutoCompleteEntry.Threshold;
+        }
+
+        private void SetItemsSource()
+        {
+            if (AutoCompleteEntry.ItemsSource != null)
+            {
+                var items = AutoCompleteEntry.ItemsSource.ToList();
+                NativeControl.UpdateItems(items);
+            }
+        }
+
+        private void KillPassword()
+        {
+            if (Element.IsPassword)
+                throw new NotImplementedException("Cannot set IsPassword on a AutoCompleteEntry");
+        }
+
+        private void ItemsSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
+        {
+            SetItemsSource();
+        }
+
+        private static UIScrollView GetParentScrollView(UIView element)
+        {
+            if (element.Superview == null) return null;
+            var scrollView = element.Superview as UIScrollView;
+            return scrollView ?? GetParentScrollView(element.Superview);
+        }
+
+        private void AutoCompleteViewSourceOnSelected(object sender, SelectedItemChangedEventArgs args)
+        {
+            AutoCompleteEntry.OnItemSelectedInternal(Element, args);
+        }
+    }
+}
diff --git a/InputKit/Platforms/iOS/Controls/MbAutoCompleteTableView.cs b/InputKit/Platforms/iOS/Controls/MbAutoCompleteTableView.cs
new file mode 100644
index 0000000..ccc47e2
--- /dev/null
+++ b/InputKit/Platforms/iOS/Controls/MbAutoCompleteTableView.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UIKit;
+
+namespace Plugin.InputKit.Platforms.iOS.Controls
+{
+    internal class MbAutoCompleteTableView : UITableView
+    {
+        private readonly UIScrollView _parentScrollView;
+
+        public MbAutoCompleteTableView(UIScrollView parentScrollView)
+        {
+            _parentScrollView = parentScrollView;
+        }
+
+        public override bool Hidden
+        {
+            get { return base.Hidden; }
+            set
+            {
+                base.Hidden = value;
+                if (_parentScrollView == null) return;
+                _parentScrollView.DelaysContentTouches = !value;
+            }
+        }
+    }
+}
diff --git a/InputKit/Platforms/iOS/Controls/MbAutoCompleteTextField.cs b/InputKit/Platforms/iOS/Controls/MbAutoCompleteTextField.cs
new file mode 100644
index 0000000..1f13d81
--- /dev/null
+++ b/InputKit/Platforms/iOS/Controls/MbAutoCompleteTextField.cs
@@ -0,0 +1,183 @@
+using CoreAnimation;
+using CoreGraphics;
+using Foundation;
+using Plugin.InputKit.Platforms.iOS.Helpers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UIKit;
+using Xamarin.Forms;
+using Xamarin.Forms.Platform.iOS;
+
+namespace Plugin.InputKit.Platforms.iOS.Controls
+{
+    [Register("MbAutoCompleteTextField")]
+    public class MbAutoCompleteTextField : UITextField, IUITextFieldDelegate
+    {
+        private MbAutoCompleteViewSource _autoCompleteViewSource;
+        private UIView _background;
+        private CGRect _drawnFrame;
+        private List<string> _items;
+        private UIViewController _parentViewController;
+        private UIScrollView _scrollView;
+
+        public Func<string, ICollection<string>, ICollection<string>> SortingAlgorithm { get; set; } = (t, d) => d;
+
+        public MbAutoCompleteViewSource AutoCompleteViewSource
+        {
+            get { return _autoCompleteViewSource; }
+            set
+            {
+                _autoCompleteViewSource = value;
+                _autoCompleteViewSource.AutoCompleteTextField = this;
+                if (AutoCompleteTableView != null)
+                {
+                    AutoCompleteTableView.Source = AutoCompleteViewSource;
+                }
+            }
+        }
+
+        public UITableView AutoCompleteTableView { get; private set; }
+
+        public bool IsInitialized { get; private set; }
+
+        public int Threshold { get; set; } = 2;
+
+        public int AutocompleteTableViewHeight { get; set; } = 150;
+
+        public void Draw(UIViewController viewController, CALayer layer, UIScrollView scrollView)
+        {
+            if (viewController == null)
+            {
+                throw new ArgumentNullException(nameof(viewController), @"View cannot be null");
+            }
+
+            _scrollView = scrollView;
+            _drawnFrame = layer.Frame;
+            _parentViewController = viewController;
+
+
+            //Make new tableview and do some settings
+            AutoCompleteTableView = new MbAutoCompleteTableView(_scrollView)
+            {
+                DelaysContentTouches = true,
+                ClipsToBounds = true,
+                ScrollEnabled = true,
+                AllowsSelection = true,
+                Bounces = false,
+                Hidden = true,
+                ContentInset = UIEdgeInsets.Zero,
+                AutoresizingMask = UIViewAutoresizing.FlexibleHeight | UIViewAutoresizing.FlexibleWidth,
+                Source = AutoCompleteViewSource,
+                TableFooterView = new UIView()
+            };
+
+            //Some textfield settings
+            AutocorrectionType = UITextAutocorrectionType.No;
+            ClearButtonMode = UITextFieldViewMode.Never;
+
+            var scrollViewIsNull = _scrollView == null;
+
+            CGRect frame;
+            UIView view;
+            if (scrollViewIsNull)
+            {
+                view = _parentViewController.View;
+                frame = new CGRect(_drawnFrame.X, _drawnFrame.Bottom + _drawnFrame.Height + 90, _drawnFrame.Width, AutocompleteTableViewHeight);
+            }
+            else
+            {
+                var e = (ScrollView)((ScrollViewRenderer)_scrollView).Element;
+                var p = e.Padding;
+                var m = e.Margin;
+                frame = new CGRect(_drawnFrame.X + p.Left + m.Left,
+                    _drawnFrame.Y + _drawnFrame.Height + 90,
+                    _drawnFrame.Width,
+                    AutocompleteTableViewHeight);
+                view = _scrollView;
+            }
+
+            AutoCompleteTableView.Layer.CornerRadius = 5;
+
+            _background = new UIView(frame) { BackgroundColor = UIColor.White, Hidden = true };
+            _background.Layer.CornerRadius = 5; //rounded corners
+            _background.Layer.MasksToBounds = false;
+            _background.Layer.ShadowColor = UIColor.Black.CGColor;
+            _background.Layer.ShadowOffset = new CGSize(0.0f, 4.0f);
+            _background.Layer.ShadowOpacity = 0.25f;
+            _background.Layer.ShadowRadius = 8f;
+            _background.Layer.BorderColor = UIColor.LightGray.CGColor;
+            _background.Layer.BorderWidth = 0.1f;
+
+            AutoCompleteTableView.Frame = frame;
+            view.AddSubview(_background);
+            view.AddSubview(AutoCompleteTableView);
+
+            //listen to edit events
+            EditingChanged += OnEditingChanged;
+            EditingDidEnd += OnEditingDidEnd;
+
+            UpdateTableViewData();
+            IsInitialized = true;
+        }
+
+        private void OnEditingDidEnd(object sender, EventArgs eventArgs)
+        {
+            HideAutoCompleteView();
+        }
+
+        private void OnEditingChanged(object sender, EventArgs eventArgs)
+        {
+            if (Text.Length >= Threshold)
+            {
+                ShowAutoCompleteView();
+                UpdateTableViewData();
+            }
+            else
+            {
+                HideAutoCompleteView();
+            }
+        }
+
+        private void ShowAutoCompleteView()
+        {
+            _background.Hidden = false;
+            AutoCompleteTableView.Hidden = false;
+            if (_scrollView != null)
+            {
+                _scrollView.ScrollRectToVisible(AutoCompleteTableView.Frame, true);
+            }
+        }
+
+        private void HideAutoCompleteView()
+        {
+            _background.Hidden = true;
+            AutoCompleteTableView.Hidden = true;
+        }
+
+        public void UpdateTableViewData()
+        {
+            var sorted = SortingAlgorithm(Text, _items);
+            if (!sorted.Any())
+            {
+                HideAutoCompleteView();
+                return;
+            }
+            AutoCompleteViewSource.Suggestions = sorted;
+            AutoCompleteTableView.ReloadData();
+
+            var f = AutoCompleteTableView.Frame;
+            var height = Math.Min(AutocompleteTableViewHeight, (int)AutoCompleteTableView.ContentSize.Height);
+            var frame = new CGRect(f.X, f.Y, f.Width, height);
+            AutoCompleteTableView.Frame = frame;
+            _background.Frame = frame;
+        }
+
+        public void UpdateItems(List<string> items)
+        {
+            _items = items;
+            AutoCompleteViewSource.UpdateSuggestions(items);
+        }
+    }
+}
diff --git a/InputKit/Platforms/iOS/Helpers/Extensions.cs b/InputKit/Platforms/iOS/Helpers/Extensions.cs
new file mode 100644
index 0000000..ba2cea8
--- /dev/null
+++ b/InputKit/Platforms/iOS/Helpers/Extensions.cs
@@ -0,0 +1,275 @@
+using Foundation;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using UIKit;
+using Xamarin.Forms;
+using Xamarin.Forms.Internals;
+using Xamarin.Forms.Platform.iOS;
+
+namespace Plugin.InputKit.Platforms.iOS.Helpers
+{
+    public static class Extensions
+    {
+        private static readonly Dictionary<ToUIFontKey, UIFont> _toUiFont = new Dictionary<ToUIFontKey, UIFont>();
+
+        public static bool IsDefault(this Span self)
+        {
+            return self.FontFamily == null &&
+                   self.FontAttributes == FontAttributes.None;
+        }
+        // literally ripped this off from X.Forms source.
+        public static T FindDescendantView<T>(this UIView view) where T : UIView
+        {
+            var queue = new Queue<UIView>();
+            queue.Enqueue(view);
+
+            while (queue.Count > 0)
+            {
+                var descendantView = queue.Dequeue();
+
+                var result = descendantView as T;
+                if (result != null)
+                    return result;
+
+                for (var i = 0; i < descendantView.Subviews.Length; i++)
+                    queue.Enqueue(descendantView.Subviews[i]);
+            }
+
+            return null;
+        }
+        public static UIWindow GetTopWindow(this UIApplication app)
+        {
+            return app.Windows.Reverse().FirstOrDefault(x => x.WindowLevel == UIWindowLevel.Normal && !x.Hidden);
+        }
+
+        public static UIView GetTopView(this UIApplication app)
+        {
+            return app.GetTopWindow().Subviews.Last();
+        }
+
+        public static UIViewController GetTopViewController(this UIApplication app)
+        {
+            var viewController = app.KeyWindow.RootViewController;
+            while (viewController.PresentedViewController != null)
+                viewController = viewController.PresentedViewController;
+
+            return viewController;
+        }
+        public static UIKeyboardType ToNative(this Keyboard input)
+        {
+            if (input == Keyboard.Url)
+            {
+                return UIKeyboardType.Url;
+            }
+            if (input == Keyboard.Email)
+            {
+                return UIKeyboardType.EmailAddress;
+            }
+            if (input == Keyboard.Numeric)
+            {
+                return UIKeyboardType.NumberPad;
+            }
+            if (input == Keyboard.Chat)
+            {
+                return UIKeyboardType.Default;
+            }
+            if (input == Keyboard.Telephone)
+            {
+                return UIKeyboardType.PhonePad;
+            }
+            if (input == Keyboard.Text)
+            {
+                return UIKeyboardType.Default;
+            }
+            return UIKeyboardType.Default;
+        }
+        public static UIFont ToUIFont(this Font self)
+        {
+            var size = (float)self.FontSize;
+            if (self.UseNamedSize)
+                switch (self.NamedSize)
+                {
+                    case NamedSize.Micro:
+                        size = 12;
+                        break;
+                    case NamedSize.Small:
+                        size = 14;
+                        break;
+                    case NamedSize.Medium:
+                        size = 17; // as defined by iOS documentation
+                        break;
+                    case NamedSize.Large:
+                        size = 22;
+                        break;
+                    default:
+                        size = 17;
+                        break;
+                }
+
+            var bold = self.FontAttributes.HasFlag(FontAttributes.Bold);
+            var italic = self.FontAttributes.HasFlag(FontAttributes.Italic);
+
+            if (self.FontFamily != null)
+                try
+                {
+                    if (UIFont.FamilyNames.Contains(self.FontFamily))
+                    {
+                        var descriptor = new UIFontDescriptor().CreateWithFamily(self.FontFamily);
+
+                        if (bold || italic)
+                        {
+                            var traits = (UIFontDescriptorSymbolicTraits)0;
+                            if (bold)
+                                traits = traits | UIFontDescriptorSymbolicTraits.Bold;
+                            if (italic)
+                                traits = traits | UIFontDescriptorSymbolicTraits.Italic;
+
+                            descriptor = descriptor.CreateWithTraits(traits);
+                            return UIFont.FromDescriptor(descriptor, size);
+                        }
+                    }
+
+                    return UIFont.FromName(self.FontFamily, size);
+                }
+                catch
+                {
+                    Debug.WriteLine("Could not load font named: {0}", self.FontFamily);
+                }
+            if (bold && italic)
+            {
+                var defaultFont = UIFont.SystemFontOfSize(size);
+
+                var descriptor = defaultFont.FontDescriptor.CreateWithTraits(UIFontDescriptorSymbolicTraits.Bold | UIFontDescriptorSymbolicTraits.Italic);
+                return UIFont.FromDescriptor(descriptor, 0);
+            }
+            if (italic)
+                return UIFont.ItalicSystemFontOfSize(size);
+
+            if (bold)
+                return UIFont.BoldSystemFontOfSize(size);
+
+            return UIFont.SystemFontOfSize(size);
+        }
+
+
+        public static UIFont ToUIFont(this Entry element)
+        {
+            return ToUIFont(element.FontFamily, (float)element.FontSize, element.FontAttributes);
+        }
+
+        private static UIFont _ToUIFont(string family, float size, FontAttributes attributes)
+        {
+            var bold = (attributes & FontAttributes.Bold) != 0;
+            var italic = (attributes & FontAttributes.Italic) != 0;
+
+            if (family != null)
+                try
+                {
+                    UIFont result;
+
+                    if (UIFont.FamilyNames.Contains(family))
+                    {
+                        var descriptor = new UIFontDescriptor().CreateWithFamily(family);
+
+                        if (bold || italic)
+                        {
+                            var traits = (UIFontDescriptorSymbolicTraits)0;
+                            if (bold)
+                                traits = traits | UIFontDescriptorSymbolicTraits.Bold;
+                            if (italic)
+                                traits = traits | UIFontDescriptorSymbolicTraits.Italic;
+
+                            descriptor = descriptor.CreateWithTraits(traits);
+                            result = UIFont.FromDescriptor(descriptor, size);
+                            if (result != null)
+                                return result;
+                        }
+                    }
+
+                    result = UIFont.FromName(family, size);
+
+                    if (result != null)
+                        return result;
+                }
+                catch
+                {
+                    Debug.WriteLine("Could not load font named: {0}", family);
+                }
+
+            if (bold && italic)
+            {
+                var defaultFont = UIFont.SystemFontOfSize(size);
+
+
+                var descriptor = defaultFont.FontDescriptor.CreateWithTraits(UIFontDescriptorSymbolicTraits.Bold | UIFontDescriptorSymbolicTraits.Italic);
+                return UIFont.FromDescriptor(descriptor, 0);
+            }
+            if (italic)
+                return UIFont.ItalicSystemFontOfSize(size);
+
+            if (bold)
+                return UIFont.BoldSystemFontOfSize(size);
+
+            return UIFont.SystemFontOfSize(size);
+        }
+
+        private static UIFont ToUIFont(string family, float size, FontAttributes attributes)
+        {
+            var key = new ToUIFontKey(family, size, attributes);
+
+            lock (_toUiFont)
+            {
+                UIFont value;
+                if (_toUiFont.TryGetValue(key, out value))
+                    return value;
+            }
+
+            var generatedValue = _ToUIFont(family, size, attributes);
+
+            lock (_toUiFont)
+            {
+                UIFont value;
+                if (!_toUiFont.TryGetValue(key, out value))
+                    _toUiFont.Add(key, value = generatedValue);
+                return value;
+            }
+        }
+
+        private struct ToUIFontKey
+        {
+            internal ToUIFontKey(string family, float size, FontAttributes attributes)
+            {
+                _family = family;
+                _size = size;
+                _attributes = attributes;
+            }
+#pragma warning disable 0414 // these are not called explicitly, but they are used to establish uniqueness. allow it!
+            // ReSharper disable once NotAccessedField.Local
+            private string _family;
+
+            // ReSharper disable once NotAccessedField.Local
+            private float _size;
+
+            // ReSharper disable once NotAccessedField.Local
+            private FontAttributes _attributes;
+#pragma warning restore 0414
+        }
+
+        public static UIFont ToUIFont(this Label label)
+
+        {
+            var values = label.GetValues(Label.FontFamilyProperty, Label.FontSizeProperty, Label.FontAttributesProperty);
+            return ToUIFont((string)values[0], (float)(double)values[1], (FontAttributes)values[2]) ??
+                   UIFont.SystemFontOfSize(UIFont.LabelFontSize);
+        }
+
+
+        public static UIFont ToUIFont(this IFontElement element)
+        {
+            return ToUIFont(element.FontFamily, (float)element.FontSize, element.FontAttributes);
+        }
+    }
+}
diff --git a/InputKit/Platforms/iOS/Helpers/MbAutoCompleteDefaultDataSource.cs b/InputKit/Platforms/iOS/Helpers/MbAutoCompleteDefaultDataSource.cs
new file mode 100644
index 0000000..e411629
--- /dev/null
+++ b/InputKit/Platforms/iOS/Helpers/MbAutoCompleteDefaultDataSource.cs
@@ -0,0 +1,31 @@
+using Foundation;
+using System.Collections.Generic;
+using System.Linq;
+using UIKit;
+
+namespace Plugin.InputKit.Platforms.iOS.Helpers
+{
+    public class MbAutoCompleteDefaultDataSource : MbAutoCompleteViewSource
+    {
+        private const string _cellIdentifier = "DefaultIdentifier";
+
+        public override void UpdateSuggestions(ICollection<string> suggestions)
+        {
+            Suggestions = suggestions;
+        }
+
+        public override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath)
+        {
+            var cell = tableView.DequeueReusableCell(_cellIdentifier);
+            var item = Suggestions.ElementAt(indexPath.Row);
+
+            if (cell == null)
+                cell = new UITableViewCell(UITableViewCellStyle.Default, _cellIdentifier);
+
+            cell.BackgroundColor = UIColor.Clear;
+            cell.TextLabel.Text = item;
+
+            return cell;
+        }
+    }
+}
diff --git a/InputKit/Platforms/iOS/Helpers/MbAutoCompleteViewSource.cs b/InputKit/Platforms/iOS/Helpers/MbAutoCompleteViewSource.cs
new file mode 100644
index 0000000..b1a5aee
--- /dev/null
+++ b/InputKit/Platforms/iOS/Helpers/MbAutoCompleteViewSource.cs
@@ -0,0 +1,40 @@
+using Foundation;
+using Plugin.InputKit.Platforms.iOS.Controls;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UIKit;
+using Xamarin.Forms;
+
+namespace Plugin.InputKit.Platforms.iOS.Helpers
+{
+
+    public abstract class MbAutoCompleteViewSource : UITableViewSource
+    {
+        public ICollection<string> Suggestions { get; set; } = new List<string>();
+
+        public MbAutoCompleteTextField AutoCompleteTextField { get; set; }
+
+        public abstract void UpdateSuggestions(ICollection<string> suggestions);
+
+        public abstract override UITableViewCell GetCell(UITableView tableView, NSIndexPath indexPath);
+
+        public override nint RowsInSection(UITableView tableview, nint section)
+        {
+            return Suggestions.Count;
+        }
+
+        public event EventHandler<SelectedItemChangedEventArgs> Selected;
+
+        public override void RowSelected(UITableView tableView, NSIndexPath indexPath)
+        {
+            AutoCompleteTextField.Text = Suggestions.ElementAt(indexPath.Row);
+            AutoCompleteTextField.AutoCompleteTableView.Hidden = true;
+            AutoCompleteTextField.ResignFirstResponder();
+            var item = Suggestions.ToList()[(int)indexPath.Item];
+            Selected?.Invoke(tableView, new SelectedItemChangedEventArgs(item));
+            // don't call base.RowSelected
+        }
+    }
+}
diff --git a/InputKit/Shared/Controls/AdvancedEntry.cs b/InputKit/Shared/Controls/AdvancedEntry.cs
index f95a32e..8c738ea 100644
--- a/InputKit/Shared/Controls/AdvancedEntry.cs
+++ b/InputKit/Shared/Controls/AdvancedEntry.cs
@@ -35,12 +35,13 @@ public partial class AdvancedEntry : StackLayout, IValidatable
         Frame frmBackground = new Frame { BackgroundColor = GlobalSetting.BackgroundColor, CornerRadius = (float)GlobalSetting.CornerRadius, BorderColor = GlobalSetting.BorderColor, Padding = 0 };
         Image imgWarning = new Image { Margin = 10, HorizontalOptions = LayoutOptions.End, VerticalOptions = LayoutOptions.Center, InputTransparent = true, Source = "alert.png" };
         IconView imgIcon = new IconView { InputTransparent = true, Margin = 10, VerticalOptions = LayoutOptions.CenterAndExpand, HeightRequest = 30, FillColor = GlobalSetting.Color };
-        Entry txtInput = new EmptyEntry { TextColor = GlobalSetting.TextColor, PlaceholderColor = Color.LightGray, HorizontalOptions = LayoutOptions.FillAndExpand, VerticalOptions = LayoutOptions.Center, FontFamily = GlobalSetting.FontFamily };
-        /// <summary>
-        /// Default Constructor
-        /// </summary>
+        Entry txtInput;
+            /// <summary>
+            /// Default Constructor
+            /// </summary>
         public AdvancedEntry()
         {
+            txtInput = GetInputEntry();
             this.Children.Add(lblTitle);
             this.Children.Add(lblAnnotation);
             this.Children.Add(frmBackground);
@@ -322,7 +323,7 @@ public bool IsAnnotated
         /// <summary>
         /// You need to set Annotation="Regex" to use this.
         /// </summary>
-        public string RegexPattern { get => (string)GetValue(RegexPatternProperty); set => SetValue(RegexPatternProperty,value); }
+        public string RegexPattern { get => (string)GetValue(RegexPatternProperty); set => SetValue(RegexPatternProperty, value); }
         /// <summary>
         /// Gets and sets keyboard type of this entry
         /// </summary>
@@ -346,11 +347,11 @@ public bool IsAnnotated
         public static readonly BindableProperty IsRequiredProperty = BindableProperty.Create(nameof(IsRequired), typeof(bool), typeof(AdvancedEntry), false, propertyChanged: (bo, ov, nv) => (bo as AdvancedEntry).UpdateWarning());
         public static readonly BindableProperty PlaceholderColorProperty = BindableProperty.Create(nameof(PlaceholderColor), typeof(Color), typeof(AdvancedEntry), Color.LightGray, propertyChanged: (bo, ov, nv) => (bo as AdvancedEntry).PlaceholderColor = (Color)nv);
         public static readonly BindableProperty CommandParameterProperty = BindableProperty.Create(nameof(CommandParameter), typeof(object), typeof(AdvancedEntry), propertyChanged: (bo, ov, nv) => (bo as AdvancedEntry).CommandParameter = nv);
-        public static readonly BindableProperty RegexPatternProperty = BindableProperty.Create(nameof(RegexPattern), typeof(string), typeof(AdvancedEntry), "", propertyChanged: (bo, ov, nv) => { (bo as AdvancedEntry).DisplayValidation(); (bo as AdvancedEntry).UpdateWarning(); } );
+        public static readonly BindableProperty RegexPatternProperty = BindableProperty.Create(nameof(RegexPattern), typeof(string), typeof(AdvancedEntry), "", propertyChanged: (bo, ov, nv) => { (bo as AdvancedEntry).DisplayValidation(); (bo as AdvancedEntry).UpdateWarning(); });
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
         #endregion
         //--------------------------------------------------------------------------------------------------------------------------------------------------
-        [Obsolete("Keyboard won't be changed automaticly on newer versions. Try set Keyboard property",false)]
+        [Obsolete("Keyboard won't be changed automaticly on newer versions. Try set Keyboard property", false)]
         public void UpdateKeyboard(AnnotationType annotation)
         {
             switch (annotation)
@@ -407,6 +408,17 @@ void UpdateWarning()
             ValidationChanged?.Invoke(this, new EventArgs());
             imgWarning.IsVisible = this.IsRequired && !this.IsAnnotated;
         }
+        private protected virtual Entry GetInputEntry()
+        {
+            return new EmptyEntry
+            {
+                TextColor = GlobalSetting.TextColor,
+                PlaceholderColor = Color.LightGray,
+                HorizontalOptions = LayoutOptions.FillAndExpand,
+                VerticalOptions = LayoutOptions.Center,
+                FontFamily = GlobalSetting.FontFamily
+            };
+        }
         /// <summary>
         /// Anum of Annotations. Detail will be added later.
         /// </summary>
diff --git a/InputKit/Shared/Controls/AutoCompleteEntry.cs b/InputKit/Shared/Controls/AutoCompleteEntry.cs
new file mode 100644
index 0000000..3de1f2b
--- /dev/null
+++ b/InputKit/Shared/Controls/AutoCompleteEntry.cs
@@ -0,0 +1,45 @@
+using Plugin.InputKit.Shared.Helpers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Xamarin.Forms;
+
+namespace Plugin.InputKit.Shared.Controls
+{
+    public class AutoCompleteEntry : AdvancedEntry
+    {
+        private AutoCompleteView txtInput;
+        public AutoCompleteEntry()
+        {
+
+        }
+
+        public IEnumerable<string> ItemsSource { get => txtInput.ItemsSource; set => txtInput.ItemsSource = value; }
+
+        #region BindableProperties
+        public static BindableProperty ItemsSourceProperty =
+            BindableProperty.Create(
+                nameof(AutoCompleteView.ItemsSource),
+                typeof(IEnumerable<string>),
+                typeof(AutoCompleteEntry),
+                propertyChanged: (bo, nv, ov) => (bo as AutoCompleteEntry).txtInput.ItemsSource = nv as IEnumerable<string>);
+        #endregion
+
+        private protected override Entry GetInputEntry()
+        {
+            txtInput = new AutoCompleteView
+            {
+                HorizontalOptions = LayoutOptions.FillAndExpand,
+                VerticalOptions = LayoutOptions.CenterAndExpand,
+            };
+            txtInput.SortingAlgorithm = (text, options) => 
+                options
+                .Where(x => x.Contains(text, StringComparison.CurrentCultureIgnoreCase))
+                .OrderBy(o => o.StartsWith(text, StringComparison.CurrentCultureIgnoreCase) ? 0 : 1)
+                .ThenBy(t => t)
+                .ToList();
+            return txtInput ;
+        }
+    }
+}
diff --git a/InputKit/Shared/Controls/AutoCompleteView.cs b/InputKit/Shared/Controls/AutoCompleteView.cs
new file mode 100644
index 0000000..66883dc
--- /dev/null
+++ b/InputKit/Shared/Controls/AutoCompleteView.cs
@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Text;
+using Xamarin.Forms;
+
+namespace Plugin.InputKit.Shared.Controls
+{
+    public class AutoCompleteView : Entry
+    {
+        private static readonly Func<string, ICollection<string>, ICollection<string>> _defaultSortingAlgorithm = (t, d) => d;
+        public AutoCompleteView()
+        {
+            
+        }
+
+        public static readonly BindableProperty SortingAlgorithmProperty = BindableProperty.Create(nameof(SortingAlgorithm),
+            typeof(Func<string, ICollection<string>, ICollection<string>>),
+            typeof(AutoCompleteView),
+            _defaultSortingAlgorithm);
+
+        public static readonly BindableProperty ItemsSourceProperty = BindableProperty.Create(nameof(ItemsSource),
+            typeof(IEnumerable<string>),
+            typeof(AutoCompleteView),
+            default(IEnumerable<string>), propertyChanged: OnItemsSourcePropertyChangedInternal);
+
+        public static readonly BindableProperty SelectedItemProperty = BindableProperty.Create(nameof(SelectedItem),
+            typeof(object),
+            typeof(AutoCompleteView),
+            default(object),
+            BindingMode.OneWayToSource);
+
+        public static readonly BindableProperty ThresholdProperty = BindableProperty.Create(nameof(Threshold),
+            typeof(int),
+            typeof(AutoCompleteView),
+            2);
+
+        /// <summary>
+        ///     Sorting Algorithm for the drop down list. This is a bindable property.
+        /// </summary>
+        /// <example>
+        /// <![CDATA[
+        /// SortingAlgorithm = (text, values) => values
+        ///     .Where(t => t.ToLower().StartsWith(text.ToLower()))
+        ///     .OrderBy(x => x)
+        ///     .ToList();
+        /// ]]>
+        /// </example>
+        public Func<string, ICollection<string>, ICollection<string>> SortingAlgorithm
+        {
+            get { return (Func<string, ICollection<string>, ICollection<string>>)GetValue(SortingAlgorithmProperty); }
+            set { SetValue(SortingAlgorithmProperty, value); }
+        }
+
+        /// <summary>
+        ///     The number of characters the user must type before the dropdown is shown. This is a bindable property.
+        /// </summary>
+        public int Threshold
+        {
+            get { return (int)GetValue(ThresholdProperty); }
+            set { SetValue(ThresholdProperty, value); }
+        }
+
+        /// <summary>
+        ///     Item selected from the DropDown List. This is a bindable property.
+        /// </summary>
+        public object SelectedItem
+        {
+            get { return GetValue(SelectedItemProperty); }
+            set { SetValue(SelectedItemProperty, value); }
+        }
+
+        /// <summary>
+        ///     Drop Down List Items Source. This is a bindable property.
+        /// </summary>
+        public IEnumerable<string> ItemsSource
+        {
+            get { return (IEnumerable<string>)GetValue(ItemsSourceProperty); }
+            set { SetValue(ItemsSourceProperty, value); }
+        }
+
+        public event EventHandler<SelectedItemChangedEventArgs> ItemSelected;
+
+        internal void OnItemSelectedInternal(object sender, SelectedItemChangedEventArgs args)
+        {
+            SelectedItem = args.SelectedItem;
+            ItemSelected?.Invoke(sender, args);
+            OnItemSelected(args);
+        }
+        private static void OnItemsSourcePropertyChangedInternal(BindableObject bindable, object oldvalue, object newvalue)
+        {
+            var combo = (AutoCompleteView)bindable;
+            var observableOld = oldvalue as INotifyCollectionChanged;
+            var observableNew = newvalue as INotifyCollectionChanged;
+            combo.OnItemsSourcePropertyChanged(combo, oldvalue, newvalue);
+
+            if (observableOld != null)
+            {
+                observableOld.CollectionChanged -= combo.OnCollectionChangedInternal;
+            }
+
+            if (observableNew != null)
+            {
+                observableNew.CollectionChanged += combo.OnCollectionChangedInternal;
+            }
+        }
+
+        public event EventHandler<NotifyCollectionChangedEventArgs> CollectionChanged;
+
+        private void OnCollectionChangedInternal(object sender, NotifyCollectionChangedEventArgs args)
+        {
+            CollectionChanged?.Invoke(sender, args);
+        }
+
+        protected virtual void OnItemsSourcePropertyChanged(AutoCompleteView bindable, object oldvalue, object newvalue) { }
+        protected virtual void OnItemSelected(SelectedItemChangedEventArgs args) { }
+    }
+}
diff --git a/InputKit/Shared/Helpers/StringExtensions.cs b/InputKit/Shared/Helpers/StringExtensions.cs
new file mode 100644
index 0000000..dbe3341
--- /dev/null
+++ b/InputKit/Shared/Helpers/StringExtensions.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Plugin.InputKit.Shared.Helpers
+{
+    public static class StringExtensions
+    {
+        public static bool Contains(this string source, string value, StringComparison comp)
+        {
+            return source?.IndexOf(value, comp) >= 0;
+        }
+    }
+}
diff --git a/Sample.InputKit/Sample.InputKit.Android/Sample.InputKit.Android.csproj b/Sample.InputKit/Sample.InputKit.Android/Sample.InputKit.Android.csproj
index 44de746..bd3c69d 100644
--- a/Sample.InputKit/Sample.InputKit.Android/Sample.InputKit.Android.csproj
+++ b/Sample.InputKit/Sample.InputKit.Android/Sample.InputKit.Android.csproj
@@ -30,6 +30,7 @@
     <AotAssemblies>false</AotAssemblies>
     <EnableLLVM>false</EnableLLVM>
     <BundleAssemblies>false</BundleAssemblies>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -43,6 +44,7 @@
     <AotAssemblies>false</AotAssemblies>
     <EnableLLVM>false</EnableLLVM>
     <BundleAssemblies>false</BundleAssemblies>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Mono.Android" />
diff --git a/Sample.InputKit/Sample.InputKit.iOS/Sample.InputKit.iOS.csproj b/Sample.InputKit/Sample.InputKit.iOS/Sample.InputKit.iOS.csproj
index aa7f17b..6ecdd8f 100644
--- a/Sample.InputKit/Sample.InputKit.iOS/Sample.InputKit.iOS.csproj
+++ b/Sample.InputKit/Sample.InputKit.iOS/Sample.InputKit.iOS.csproj
@@ -26,6 +26,7 @@
     <MtouchArch>x86_64</MtouchArch>
     <MtouchLink>None</MtouchLink>
     <MtouchDebug>true</MtouchDebug>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|iPhoneSimulator' ">
     <DebugType>none</DebugType>
@@ -36,6 +37,7 @@
     <MtouchLink>None</MtouchLink>
     <MtouchArch>x86_64</MtouchArch>
     <ConsolePause>false</ConsolePause>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|iPhone' ">
     <DebugSymbols>true</DebugSymbols>
@@ -87,6 +89,12 @@
     <CodesignKey>iPhone Distribution</CodesignKey>
     <CodesignEntitlements>Entitlements.plist</CodesignEntitlements>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Ad-Hoc|iPhoneSimulator'">
+    <LangVersion>7.2</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'AppStore|iPhoneSimulator'">
+    <LangVersion>7.2</LangVersion>
+  </PropertyGroup>
   <ItemGroup>
     <Compile Include="Main.cs" />
     <Compile Include="AppDelegate.cs" />
diff --git a/Sample.InputKit/Sample.InputKit/MainPage.xaml b/Sample.InputKit/Sample.InputKit/MainPage.xaml
index 9f82765..aab0219 100644
--- a/Sample.InputKit/Sample.InputKit/MainPage.xaml
+++ b/Sample.InputKit/Sample.InputKit/MainPage.xaml
@@ -13,7 +13,9 @@
 
             <Button Text="CheckBoxes" Clicked="CheckBoxes_Clicked" />
             <Button Text="RadioButons" Clicked="RadioButons_Clicked" />
+            <Button Text="AutoCompleteEntries" Clicked="AutoCompleteEntries_Clicked" />
 
+            
             <input:Dropdown Title="Chosse an option below:"                            
                             TitleColor="Black"
                             Color="Green"
diff --git a/Sample.InputKit/Sample.InputKit/MainPage.xaml.cs b/Sample.InputKit/Sample.InputKit/MainPage.xaml.cs
index 4aad258..7b3c363 100644
--- a/Sample.InputKit/Sample.InputKit/MainPage.xaml.cs
+++ b/Sample.InputKit/Sample.InputKit/MainPage.xaml.cs
@@ -41,5 +41,18 @@ private void Button_Clicked(object sender, EventArgs e)
         private void CheckBoxes_Clicked(object sender, EventArgs e) => Navigation.PushAsync(new CheckBoxesPage());
 
         private void RadioButons_Clicked(object sender, EventArgs e) => Navigation.PushAsync(new RadioButtonsPage());
+
+        private void AutoCompleteEntries_Clicked(object sender, EventArgs e)
+        {
+            try
+            {
+                Navigation.PushAsync(new AutoCompleteEntriesPage());
+
+            }
+            catch (Exception ex)
+            {
+                DisplayAlert("Error:", ex.ToString(), "ok");
+            }
+        }
     }
 }
diff --git a/Sample.InputKit/Sample.InputKit/Sample.InputKit.csproj b/Sample.InputKit/Sample.InputKit/Sample.InputKit.csproj
index 792dec3..ccc5be0 100644
--- a/Sample.InputKit/Sample.InputKit/Sample.InputKit.csproj
+++ b/Sample.InputKit/Sample.InputKit/Sample.InputKit.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -33,6 +34,9 @@
   </ItemGroup>
 
   <ItemGroup>
+    <EmbeddedResource Update="Views\AutoCompleteEntriesPage.xaml">
+      <Generator>MSBuild:UpdateDesignTimeXaml</Generator>
+    </EmbeddedResource>
     <EmbeddedResource Update="Views\CheckBoxesPage.xaml">
       <Generator>MSBuild:UpdateDesignTimeXaml</Generator>
     </EmbeddedResource>
diff --git a/Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml b/Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml
new file mode 100644
index 0000000..9886df3
--- /dev/null
+++ b/Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:input="clr-namespace:Plugin.InputKit.Shared.Controls;assembly=Plugin.InputKit"
+             x:Class="Sample.InputKit.Views.AutoCompleteEntriesPage"
+             Title="AutoCompleteEntries">
+    <ContentPage.Content>
+        <StackLayout x:Name="mainLayout" Padding="25" Spacing="15">
+            <input:AutoCompleteEntry 
+                x:Name="autoCompleteEntry"
+                Title="Type something"
+                Placeholder="Here you go..."
+                IconImage="ic_account_balance_black">
+            </input:AutoCompleteEntry>
+        </StackLayout>
+    </ContentPage.Content>
+</ContentPage>
\ No newline at end of file
diff --git a/Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml.cs b/Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml.cs
new file mode 100644
index 0000000..5793e99
--- /dev/null
+++ b/Sample.InputKit/Sample.InputKit/Views/AutoCompleteEntriesPage.xaml.cs
@@ -0,0 +1,39 @@
+using Plugin.InputKit.Shared.Controls;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Xamarin.Forms;
+using Xamarin.Forms.Xaml;
+
+namespace Sample.InputKit.Views
+{
+    [XamlCompilation(XamlCompilationOptions.Compile)]
+    public partial class AutoCompleteEntriesPage : ContentPage
+    {
+        public AutoCompleteEntriesPage()
+        {
+            InitializeComponent();
+            var source = new ObservableCollection<string>();
+            autoCompleteEntry.ItemsSource = source;
+            source.Add("Option 1");
+            source.Add("Option 2");
+            source.Add("Test 1");
+            source.Add("Test 2");
+            source.Add("Test 3");
+            source.Add("Test 4");
+            source.Add("Sample");
+            source.Add("Xamarin");
+            source.Add("Xamarin Forms");
+            source.Add("Xamarin Droid");
+            source.Add("Xamarin Android");
+            source.Add("Xamarin iOS");
+            source.Add("Xamarin Apple");
+            source.Add("Xamarin Mac");
+            source.Add("Xamarin UWP");
+        }
+    }
+}
\ No newline at end of file