/// <summary>
        /// A method for getting tokens containing mutible words
        /// </summary>
        private ICharSequence InnerToken(ICharSequence text)
        {
            int i = text.Length();

            // Find the first space in the Token, going backwards
            while (i > 0 && text.CharAt(i - 1) == ' ')
            {
                i--;
            }

            if (i > 0 && text.CharAt(i - 1) == ' ')
            {
                return text;
            }
            else
            {
                if (text.GetType().IsInstanceOfType(typeof(ISpanned)))
                {
                    SpannableString sp = new SpannableString(text + " ");
                    TextUtils.CopySpansFrom((ISpanned)text, 0, text.Length(), Java.Lang.Class.FromType(typeof(Java.Lang.Object)), sp, 0);
                    return sp;
                }
                else
                {
                    return new Java.Lang.String(text + " ");
                }
            }
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="field">Name of the field query will use.</param>
 /// <param name="term">Term token to use for building term for the query</param>
 /// <param name="minSimilarity">similarity value</param>
 /// <param name="begin">position in the query string</param>
 /// <param name="end">position in the query string</param>
 public FuzzyQueryNode(string field, ICharSequence term,
     float minSimilarity, int begin, int end)
     : base(field, term, begin, end)
 {
     this.similarity = minSimilarity;
     IsLeaf = true;
 }

 void ITextWatcher.BeforeTextChanged(ICharSequence s, int start, int count, int after)
 {
     if (BeforeTextChanged != null)
     {
         BeforeTextChanged(s, start, count, after);
     }
 }

        private static ICharSequence EscapeChar(ICharSequence str, CultureInfo locale)
        {
            if (str == null || str.Length == 0)
                return str;

            ICharSequence buffer = str;

            // regular escapable Char for terms
            for (int i = 0; i < escapableTermChars.Length; i++)
            {
                buffer = ReplaceIgnoreCase(buffer, escapableTermChars[i].ToLower(locale),
                    "\\", locale);
            }

            // First Character of a term as more escaping chars
            for (int i = 0; i < escapableTermExtraFirstChars.Length; i++)
            {
                if (buffer[0] == escapableTermExtraFirstChars[i][0])
                {
                    buffer = new StringCharSequenceWrapper("\\" + buffer[0]
                        + buffer.SubSequence(1, buffer.Length).ToString());
                    break;
                }
            }

            return buffer;
        }

		public SimpleMenuItem (SimpleMenu menu, int id, int order, ICharSequence title)
		{
			mMenu = menu;
			mId = id;
			mOrder = order;
			mTitle = title;
		}

        public static ICharSequence Parse(Context context, IList<IconFontDescriptorWrapper> iconFontDescriptors,
            ICharSequence text, TextView target)
        {
            context = context.ApplicationContext;

            // Analyse the text and replace {} blocks With the appropriate character
            // Retain all transformations in the accumulator
            var spannableBuilder = new SpannableStringBuilder(text);
            RecursivePrepareSpannableIndexes(context, text.ToString(), spannableBuilder, iconFontDescriptors, 0);
            var isAnimated = HasAnimatedSpans(spannableBuilder);

            // If animated, periodically invalidate the TextView so that the
            // CustomTypefaceSpan can redraw itself
            if (isAnimated)
            {
                if (target == null)
                {
                    throw new ArgumentException("You can't use \"spin\" without providing the target TextView.");
                }
                if (!(target is IHasOnViewAttachListener))
                {
                    throw new ArgumentException(target.GetType().Name + " does not implement " +
                                                "HasOnViewAttachListener. Please use IconTextView, IconButton or IconToggleButton.");
                }

                ((IHasOnViewAttachListener) target).OnViewAttachListener =
                    new OnViewAttachListenerOnViewAttachListenerAnonymousInnerClassHelper(target);
            }
            else if (target is IHasOnViewAttachListener)
            {
                ((IHasOnViewAttachListener) target).OnViewAttachListener = null;
            }

            return spannableBuilder;
        }

 /**
  * Create a new instance of MyFragment that will be initialized
  * with the given arguments.
  */
 internal static MyFragment NewInstance(ICharSequence label) {
     MyFragment f = new MyFragment();
     Bundle b = new Bundle();
     b.PutCharSequence("label", label);
     f.SetArguments(b);
     return f;
 }

 void ITextWatcher.OnTextChanged(ICharSequence s, int start, int before, int count)
 {
     if (OnTextChanged != null)
     {
         OnTextChanged(new TextChangedEventArgs(s, start, before, count));
     }
 }

 protected override FilterResults PerformFiltering(ICharSequence constraint)
 {
     var results = performFilteringHandler(constraint.ToString());
     return new FilterResults
     {
         Count = results.Size(),
         Values = results
     };
 }

		protected override FilterResults PerformFiltering (ICharSequence constraint)
		{
			if (filterResults == null) {
				filterResults = new FilterResults ();
			}

			Task.Run (async () => await SearchWithStringAsync (constraint));

			return filterResults;
		}

 /// <summary>
 /// Create a non-escaped <see cref="ICharSequence"/>
 /// </summary>
 public UnescapedCharSequence(ICharSequence text)
 {
     this.chars = new char[text.Length];
     this.wasEscaped = new bool[text.Length];
     for (int i = 0; i < text.Length; i++)
     {
         this.chars[i] = text[i];
         this.wasEscaped[i] = false;
     }
 }

            protected override FilterResults PerformFiltering(ICharSequence constraint)
            {
                var stringConstraint = constraint == null ? string.Empty : constraint.ToString();

                var count = _owner.SetConstraintAndWaitForDataChange(stringConstraint);

                return new FilterResults
                    {
                        Count = count
                    };
            }

            public ICharSequence FilterFormatted(ICharSequence source, int start, int end, ISpanned dest, int dstart, int dend)
            {
                for (int i = start; i < end; ++i)
                {
                    if (!Character.IsDigit(source.CharAt(i)) && !backgroundHintTextView.IsCharInFilter(source.CharAt(i)))
                    {
                        return new Java.Lang.String("");
                    }
                }

                return null;
            }

		async Task SearchWithStringAsync (ICharSequence constraint)
		{
			var searchString = constraint?.ToString ();

			if (searchString == null) {
				LocationResults = new List<WuAcLocation> ();
				ResultStrings = new List<SpannableString> ();
				return;
			}

			bool canceled = false;

			try {

				ResultStrings = new List<SpannableString> ();

				if (!string.IsNullOrWhiteSpace (searchString)) {

					LocationResults = await WuAcClient.GetAsync (searchString);

					Java.Lang.Object [] matchObjects = new Java.Lang.Object [LocationResults.Count];

					for (int i = 0; i < LocationResults.Count; i++) {

						var name = LocationResults [i].name;

						ResultStrings.Add (name.GetSearchResultSpannableString (searchString));

						matchObjects [i] = new Java.Lang.String (name);
					}

					filterResults.Values = matchObjects;
					filterResults.Count = LocationResults.Count;

				} else {

					LocationResults = new List<WuAcLocation> ();
				}

			} catch (System.Exception ex) {

				System.Diagnostics.Debug.WriteLine (ex.Message);

				canceled = true;

			} finally {

				if (!canceled) {
					publish = true;
					Activity.RunOnUiThread (() => PublishResults (constraint, filterResults));
				}
			}
		}

        public override void Draw(Canvas canvas, ICharSequence text, int start, int end, float x, int top, int y, int bottom, Paint paint)
        {
            PrepView();

            canvas.Save();

            //Centering the token looks like a better strategy that aligning the bottom
            int padding = (bottom - top - View.Bottom) / 2;
            canvas.Translate(x, bottom - View.Bottom - padding);
            View.Draw(canvas);
            canvas.Restore();
        }

 public void BeforeTextChanged(ICharSequence s, int start, int count, int after)
 {
     if (s.Length() > 4)
     {
         mTextInputLayout.SetError("学号输入错误！");
         mTextInputLayout.SetErrorEnabled(true);
     }
     else
     {
         mTextInputLayout.SetErrorEnabled(false);
     }
 }

        public override void OnAuthenticationError(FingerprintState errorCode, ICharSequence errString)
        {
            base.OnAuthenticationError(errorCode, errString);
            var message = errString != null ? errString.ToString() : string.Empty;
            var result = new FingerprintAuthenticationResult { Status = FingerprintAuthenticationResultStatus.Failed, ErrorMessage = message };

            if (errorCode == FingerprintState.ErrorLockout)
            {
                result.Status = FingerprintAuthenticationResultStatus.TooManyAttempts;
            }

            SetResultSafe(result);
        }

 public override int GetSize(Paint paint, ICharSequence text, int start, int end, Paint.FontMetricsInt fm)
 {
     LocalPaint.Set(paint);
     ApplyCustomTypeFace(LocalPaint, _typeface);
     LocalPaint.GetTextBounds(_icon, 0, 1, TextBounds);
     if (fm != null)
     {
         fm.Descent = (int) (TextBounds.Height()*BaselineRatio);
         fm.Ascent = -(TextBounds.Height() - fm.Descent);
         fm.Top = fm.Ascent;
         fm.Bottom = fm.Descent;
     }
     return TextBounds.Width();
 }

        private ICharSequence EscapeQuoted(ICharSequence str, CultureInfo locale)
        {
            if (str == null || str.Length == 0)
                return str;

            ICharSequence buffer = str;

            for (int i = 0; i < escapableQuotedChars.Length; i++)
            {
                buffer = ReplaceIgnoreCase(buffer, escapableTermChars[i].ToLower(locale),
                    "\\", locale);
            }
            return buffer;
        }

 public override int GetSize(Paint paint, ICharSequence text, int start, int end, Paint.FontMetricsInt fm)
 {
     LOCAL_PAINT.Set(paint);
     ApplyCustomTypeFace(LOCAL_PAINT, type);
     LOCAL_PAINT.GetTextBounds(icon, 0, 1, TEXT_BOUNDS);
     if (fm != null)
     {
         float baselineRatio = baselineAligned ? 0 : BASELINE_RATIO;
         fm.Descent = (int)(TEXT_BOUNDS.Height() * baselineRatio);
         fm.Ascent = -(TEXT_BOUNDS.Height() - fm.Descent);
         fm.Top = fm.Ascent;
         fm.Bottom = fm.Descent;
     }
     return TEXT_BOUNDS.Width();
 }