TextChanged doesn't fire in Editor Custom Renderer EditorRenderer

Thanks Cole, that did work. However, I realize now that I want to use the Editor Text property instead of a callback event. So I tried to use your idea to modify the property but when I do OnElementPropertyChanged is called, which calls the base.OnElementPropertyChanged which changes it back to the original value!?! Obviously I'm doing something wrong here. Also, I wonder in the back of my head why I have to reproduce the code that works without my renderer, but if that's way, I'm fine with it. But how can I get this working. Keep in mind my object names are different than the code I pointed you to.

Here's my XAML:

        <controls:EditorExtension
            x:Name="LyricEditor" 
            Text="{Binding CurrentLyric, Mode=TwoWay}"
            EndSelection="{Binding EndSel, Mode=TwoWay}"
            StartSelection="{Binding StartSel, Mode=TwoWay}"
            VerticalOptions="StartAndExpand"
            AutoSize="TextChanges"
            FontSize="Large"
            Placeholder="Add or paste your lyrics here.  Use Split to move unselected text to new section"
            SelectionChanged="SelectionChanged"
            />

And here's the renderer:

[assembly: ExportRenderer(typeof(EditorExtension), typeof(EditorRendererExtended))]
namespace HarmApp.Droid.UIExtensions
{
    public class EditorRendererExtended : EditorRenderer , MyEditText.EditTextSelectChange
    {
        Context _context;
        public EditorRendererExtended(Context context) : base(context)
        {
            _context = context;
        }

        protected override void OnElementChanged(ElementChangedEventArgs<Editor> e)
        {
            base.OnElementChanged(e);

            if(e.OldElement != null)
            {
                int x = 0;
            }

            MyEditText myEditText = new MyEditText(_context);
            myEditText.Text = Element.Text;
            myEditText.setEditTextSelectChange(this);

            SetNativeControl(myEditText);
        }

        public void change(int startPos, int selEnd)
        {
            ((EditorExtension)Element).SelectionChange(startPos, startPos);
        }

        protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            base.OnElementPropertyChanged(sender, e);
            if (Control != null)
            {
                Control.RequestFocus();

                var element = (EditorExtension)Element;

                if(e.PropertyName=="Text")
                {
                    element.EndSelection = element.StartSelection;
                }
                else
                {

                }

                Control.SetSelection(element.StartSelection, element.EndSelection);
            }
        }

        public void TextChanged(string oldValue, string newValue)
        {
            ((EditorExtension)Element).Text = newValue;
            Control.SetSelection(((EditorExtension)Element).StartSelection + 1, ((EditorExtension)Element).EndSelection + 1);
        }
    }

    class MyEditText : FormsEditText
    {

        private EditTextSelectChange editTextSelectChange;

        public MyEditText(Context context) : base(context)
        {
            this.BeforeTextChanged += MyEditText_BeforeTextChanged;
            this.AfterTextChanged += MyEditText_AfterTextChanged;
        }

        public void setEditTextSelectChange(EditTextSelectChange editTextSelectChange)
        {
            this.editTextSelectChange = editTextSelectChange;
        }

        protected override void OnSelectionChanged(int selStart, int selEnd)
        {
            base.OnSelectionChanged(selStart, selEnd);
            if (this.editTextSelectChange != null)
            {
                editTextSelectChange.change(selStart, selEnd);
            }
        }

        string before, after;
        private void MyEditText_AfterTextChanged(object sender, Android.Text.AfterTextChangedEventArgs e)
        {
            after = e.Editable.ToString();
            if (this.editTextSelectChange != null)
            {
                editTextSelectChange.TextChanged(before, after);
            }
        }

        private void MyEditText_BeforeTextChanged(object sender, Android.Text.TextChangedEventArgs e)
        {
            before = e.Text.ToString();
        }

        public interface EditTextSelectChange
        {
            void change(int lastPos, int curPos);
            void TextChanged(string oldValue, string newValue);
        }
    }
}

And here's my editor

namespace HarmApp.UIExtensions
{
    public class EditorExtension : Editor
    {
        public static BindableProperty EndSelectionProperty
            = BindableProperty.Create(nameof(EndSelectionProperty), typeof(int), typeof(EditorExtension), defaultBindingMode: BindingMode.TwoWay);

        public int EndSelection
        {
            get { return (int)GetValue(EndSelectionProperty); }
            set { SetValue(EndSelectionProperty, value); }
        }

        public static BindableProperty StartSelectionProperty
            = BindableProperty.Create(nameof(StartSelectionProperty), typeof(int), typeof(EditorExtension), defaultBindingMode: BindingMode.TwoWay);

        public int StartSelection
        {
            get { return (int)GetValue(StartSelectionProperty); }
            set { SetValue(StartSelectionProperty, value); }
        }

        public static readonly BindableProperty SelectionChangedProperty =
                    BindableProperty.Create("SelectionChanged", typeof(EventHandler), typeof(EditorExtension), null);

        public event EventHandler SelectionChanged;

        public void SelectionChange(int startIndex, int endIndex)
        {
            EventHandler eventHandler = this.SelectionChanged;
            SelectionEventArgs selectionEventArgs = new SelectionEventArgs() { startPos = startIndex, endPos = endIndex };
            eventHandler?.Invoke((object)this, selectionEventArgs);
        }

        public class SelectionEventArgs : EventArgs
        {
            public int startPos { get; set; }
            public int endPos { get; set; }
        }

        //public static readonly BindableProperty MyTextChangedProperty =
        //        BindableProperty.Create("MyTextChanged", typeof(EventHandler), typeof(EditorExtension), null);

        //public event EventHandler<TextChangedEventArgs> MyTextChanged;

        //public void TextChange(string oldValue, string newValue)
        //{
        //    EventHandler<TextChangedEventArgs> eventHandler = this.MyTextChanged;
        //    TextChangedEventArgs args = new TextChangedEventArgs(oldValue, newValue);
        //    eventHandler?.Invoke((object)this, args);
        //}

        public static readonly BindableProperty EditorTextProperty =
                BindableProperty.Create("Text", typeof(string), typeof(EditorExtension), defaultBindingMode: BindingMode.TwoWay);

        public string Text
        {
            get { return (string)GetValue(EditorTextProperty); }
            set { SetValue(EditorTextProperty, value); }
        }
    }
}