[android] improve FormattedString performance

Context: https://github.com/Redth/MauiCollectionViewGallery
Fixes: dotnet#14222

This will conflict with:

* dotnet#20352

But I will rework this after it is merged.

Profiling the above sample while scrolling on a Pixel 5, a lot of time
is spent in `FormattedStringExtensions.RecalculateSpanPositions()`:

    (20%) Microsoft.Maui.Controls!Microsoft.Maui.Controls.Platform.FormattedStringExtensions.RecalculateSpanPositions(Android.Widget.TextView,Microsoft.Maui.Controls.Label,Android.Text.SpannableString,Microsoft.Maui.SizeRequest)
    (11%) Microsoft.Maui.Controls!Microsoft.Maui.Controls.Platform.FormattedStringExtensions.FontSpan.UpdateDrawState(Android.Text.TextPaint)
    (11%) Microsoft.Maui.Controls!Microsoft.Maui.Controls.Platform.FormattedStringExtensions.FontSpan.Apply(Android.Text.TextPaint)
    (6.3%) MauiCollectionViewGallery!PoolMathApp.Helpers.FormattedTextExtensions.ToFormattedString(PoolMathApp.Models.FormattedTex

The key contributors are `FontSpan` and `LineHeightSpan` which:

* Implement `MetricAffectingSpan`, an abstract class that allows to
  change the metrics of the text.

* Implement `UpdateDrawState()` and `Apply()` methods that are called
  during draw. Causing frequent Java -> C# interop.

To fix this, let's move the following types from C# to Java:

* `FontSpan` -> `PlatformFontSpan`
* `LetterSpacingSpan` -> `PlatformFontSpan` (use different ctor)
* `LineHeightSpan` -> `PlatformLineHeightSpan`

`PlatformLineHeightSpan` is similar, as it is an implementation of the
`LineHeightSpan` interface.

With these changes, I see a nice improvement while scrolling:

    (5.5%) Microsoft.Maui.Controls!Microsoft.Maui.Controls.Platform.FormattedStringExtensions.RecalculateSpanPositions(Android.Widget.TextView,Microsoft.Maui.Controls.Label,Android.Text.SpannableString,Microsoft.Maui.SizeRequest)
    (4.0%) MauiCollectionViewGallery!PoolMathApp.Helpers.FormattedTextExtensions.ToFormattedString(PoolMathApp.Models.FormattedText

`RecalculateSpanPositions` overall, went from 20% to 5.5%!

Comparing the new types, the times spent calling the constructors are
also improved:

    Before:
    (1.1%) Microsoft.Maui.Controls!Microsoft.Maui.Controls.Platform.FormattedStringExtensions.FontSpan..ctor(Microsoft.Maui.Font,M
    (1.5%) Microsoft.Maui.Controls!Microsoft.Maui.Controls.Platform.FormattedStringExtensions.LetterSpacingSpan..ctor(double)
    After:
    (1.0%) Microsoft.Maui!Microsoft.Maui.PlatformFontSpan..ctor(Android.Content.Context,Android.Graphics.Typeface,bool,single)
    (0.82%) Microsoft.Maui!Microsoft.Maui.PlatformFontSpan..ctor(single)

This should be reasonable for .NET 8servicing, as there should be no
behavior changes and no API changes.

In a future PR, it looks like `FormattedStringExtensions` could be
improved further, but this is a decent starting point that makes it a
lot better.

Author: jonathanpeppers

src/Controls/src/Core/Platform/Android/Extensions/FormattedStringExtensions.cs

@@ -102,21 +102,21 @@ internal static SpannableString ToSpannableStringNewWay(
 
 				// LineHeight
 				if (span.LineHeight >= 0)
-					spannable.SetSpan(new LineHeightSpan(span.LineHeight), start, end, SpanTypes.InclusiveExclusive);
+					spannable.SetSpan(new PlatformLineHeightSpan((float)span.LineHeight), start, end, SpanTypes.InclusiveExclusive);
 
 				// CharacterSpacing
 				var characterSpacing = span.CharacterSpacing >= 0
 					? span.CharacterSpacing
 					: defaultCharacterSpacing;
 				if (characterSpacing >= 0)
-					spannable.SetSpan(new LetterSpacingSpan(characterSpacing.ToEm()), start, end, SpanTypes.InclusiveInclusive);
+					spannable.SetSpan(new PlatformFontSpan(characterSpacing.ToEm()), start, end, SpanTypes.InclusiveInclusive);
 
 				// Font
 				var font = span.ToFont(defaultFontSize);
 				if (font.IsDefault && defaultFont.HasValue)
 					font = defaultFont.Value;
 				if (!font.IsDefault)
-					spannable.SetSpan(new FontSpan(font, fontManager, context), start, end, SpanTypes.InclusiveInclusive);
+					spannable.SetSpan(new PlatformFontSpan(context ?? AAplication.Context, font.ToTypeface(fontManager), font.AutoScalingEnabled, (float)font.Size), start, end, SpanTypes.InclusiveInclusive);
 
 				// TextDecorations
 				var textDecorations = span.IsSet(Span.TextDecorationsProperty)
@@ -224,84 +224,5 @@ public static void RecalculateSpanPositions(this TextView textView, Label elemen
 				((ISpatialElement)span).Region = Region.FromRectangles(spanRectangles).Inflate(10);
 			}
 		}
-
-		class FontSpan : MetricAffectingSpan
-		{
-			readonly Font _font;
-			readonly IFontManager _fontManager;
-			readonly Context? _context;
-
-			public FontSpan(Font font, IFontManager fontManager, Context? context)
-			{
-				_font = font;
-				_fontManager = fontManager;
-				_context = context;
-			}
-
-			public override void UpdateDrawState(TextPaint? tp)
-			{
-				if (tp != null)
-					Apply(tp);
-			}
-
-			public override void UpdateMeasureState(TextPaint p)
-			{
-				Apply(p);
-			}
-
-			void Apply(TextPaint paint)
-			{
-				paint.SetTypeface(_font.ToTypeface(_fontManager));
-
-				paint.TextSize = TypedValue.ApplyDimension(
-					_font.AutoScalingEnabled ? ComplexUnitType.Sp : ComplexUnitType.Dip,
-					(float)_font.Size,
-					(_context ?? AAplication.Context)?.Resources?.DisplayMetrics);
-			}
-		}
-
-		class LetterSpacingSpan : MetricAffectingSpan
-		{
-			readonly float _letterSpacing;
-
-			public LetterSpacingSpan(double letterSpacing)
-			{
-				_letterSpacing = (float)letterSpacing;
-			}
-
-			public override void UpdateDrawState(TextPaint? tp)
-			{
-				if (tp != null)
-					Apply(tp);
-			}
-
-			public override void UpdateMeasureState(TextPaint p)
-			{
-				Apply(p);
-			}
-
-			void Apply(TextPaint paint)
-			{
-				paint.LetterSpacing = _letterSpacing;
-			}
-		}
-
-		class LineHeightSpan : Java.Lang.Object, ILineHeightSpan
-		{
-			readonly double _relativeLineHeight;
-
-			public LineHeightSpan(double relativeLineHeight)
-			{
-				_relativeLineHeight = relativeLineHeight;
-			}
-
-			public void ChooseHeight(Java.Lang.ICharSequence? text, int start, int end, int spanstartv, int lineHeight, Paint.FontMetricsInt? fm)
-			{
-				if (fm is null)
-					return;
-
-				fm.Ascent = (int)(fm.Top * _relativeLineHeight);
-			}
-		}
 	}
 }

src/Core/AndroidNative/maui/src/main/java/com/microsoft/maui/PlatformFontSpan.java

@@ -0,0 +1,68 @@
+package com.microsoft.maui;
+
+import android.content.Context;
+import android.graphics.Typeface;
+import android.text.TextPaint;
+import android.text.style.MetricAffectingSpan;
+import android.util.TypedValue;
+
+import androidx.annotation.NonNull;
+
+/**
+ * Class for setting letterSpacing, textSize, or typeface on a Span
+ */
+public class PlatformFontSpan extends MetricAffectingSpan {
+    // NOTE: java.lang.Float is a "nullable" float
+    private Float letterSpacing;
+    private Float textSize;
+    private Typeface typeface;
+
+    /**
+     * Constructor for setting letterSpacing-only
+     * @param letterSpacing
+     */
+    public PlatformFontSpan(float letterSpacing) {
+        this.letterSpacing = letterSpacing;
+    }
+
+    /**
+     * Constructor for setting typeface and computing textSize
+     * @param context
+     * @param typeface
+     * @param autoScalingEnabled
+     * @param fontSize
+     */
+    public PlatformFontSpan(@NonNull Context context, Typeface typeface, boolean autoScalingEnabled, float fontSize) {
+        this.typeface = typeface;
+        textSize = TypedValue.applyDimension(
+            autoScalingEnabled ? TypedValue.COMPLEX_UNIT_SP : TypedValue.COMPLEX_UNIT_DIP,
+            fontSize,
+            context.getResources().getDisplayMetrics()
+        );
+    }
+
+    @Override
+    public void updateDrawState(TextPaint textPaint) {
+        if (textPaint != null) {
+            apply(textPaint);
+        }
+    }
+
+    @Override
+    public void updateMeasureState(@NonNull TextPaint textPaint) {
+        apply(textPaint);
+    }
+
+    void apply(TextPaint textPaint)
+    {
+        if (typeface != null) {
+            textPaint.setTypeface(typeface);
+        }
+        if (textSize != null) {
+            textPaint.setTextSize(textSize);
+        }
+        if (letterSpacing != null) {
+            textPaint.setLetterSpacing(letterSpacing);
+        }
+    }
+}

src/Core/AndroidNative/maui/src/main/java/com/microsoft/maui/PlatformLineHeightSpan.java

@@ -0,0 +1,22 @@
+package com.microsoft.maui;
+
+import android.graphics.Paint;
+import android.text.style.LineHeightSpan;
+
+/**
+ * Class for setting a relativeLineHeight on a Span
+ */
+public class PlatformLineHeightSpan implements LineHeightSpan {
+    private float relativeLineHeight;
+
+    public PlatformLineHeightSpan(float relativeLineHeight) {
+        this.relativeLineHeight = relativeLineHeight;
+    }
+
+    @Override
+    public void chooseHeight(CharSequence charSequence, int i, int i1, int i2, int i3, Paint.FontMetricsInt fontMetricsInt) {
+        if (fontMetricsInt != null) {
+            fontMetricsInt.ascent = (int)(fontMetricsInt.top * relativeLineHeight);
+        }
+    }
+}