[widget audit] toga.Font

android/src/toga_android/fonts.py

@@ -1,17 +1,19 @@
-import os
+from pathlib import Path
 
-import toga
 from toga.fonts import (
     _REGISTERED_FONT_CACHE,
     BOLD,
     CURSIVE,
     FANTASY,
     ITALIC,
+    MESSAGE,
     MONOSPACE,
+    OBLIQUE,
     SANS_SERIF,
     SERIF,
     SYSTEM,
     SYSTEM_DEFAULT_FONT_SIZE,
+    SYSTEM_DEFAULT_FONTS,
 )
 from toga_android.libs.android.graphics import Typeface
 from toga_android.libs.android.util import TypedValue
@@ -44,24 +46,28 @@ def apply(self, tv, default_size, default_typeface):
             typeface = _FONT_CACHE[cache_key]
         except KeyError:
             typeface = None
-            font_key = self.interface.registered_font_key(
+            font_key = self.interface._registered_font_key(
                 self.interface.family,
                 weight=self.interface.weight,
                 style=self.interface.style,
                 variant=self.interface.variant,
             )
-            if font_key in _REGISTERED_FONT_CACHE:
-                font_path = str(
-                    toga.App.app.paths.app / _REGISTERED_FONT_CACHE[font_key]
-                )
-                if os.path.isfile(font_path):
+            try:
+                font_path = _REGISTERED_FONT_CACHE[font_key]
+            except KeyError:
+                # Not a pre-registered font
+                if self.interface.family not in SYSTEM_DEFAULT_FONTS:
+                    print(
+                        f"Unknown font '{self.interface}'; "
+                        "using system font as a fallback"
+                    )
+            else:
+                if Path(font_path).is_file():
                     typeface = Typeface.createFromFile(font_path)
-                    # If the typeface cannot be created, following Exception is thrown:
-                    # E/Minikin: addFont failed to create font, invalid request
-                    # It does not kill the app, but there is currently no way to
-                    # catch this Exception on Android
+                    if typeface is Typeface.DEFAULT:
+                        raise ValueError(f"Unable to load font file {font_path}")
                 else:
-                    print(f"Registered font path {font_path!r} could not be found")
+                    raise ValueError(f"Font file {font_path} could not be found")
 
             if typeface is None:
                 if self.interface.family is SYSTEM:
@@ -70,6 +76,8 @@ def apply(self, tv, default_size, default_typeface):
                     # (600 or 700). To preserve this, we use the widget's original
                     # typeface as a starting point rather than Typeface.DEFAULT.
                     typeface = default_typeface
+                elif self.interface.family is MESSAGE:
+                    typeface = Typeface.DEFAULT
                 elif self.interface.family is SERIF:
                     typeface = Typeface.SERIF
                 elif self.interface.family is SANS_SERIF:
@@ -87,25 +95,14 @@ def apply(self, tv, default_size, default_typeface):
                     typeface = Typeface.create(self.interface.family, Typeface.NORMAL)
 
             native_style = typeface.getStyle()
-            if self.interface.weight is not None:
-                native_style = set_bits(
-                    native_style, Typeface.BOLD, self.interface.weight == BOLD
-                )
-            if self.interface.style is not None:
-                native_style = set_bits(
-                    native_style, Typeface.ITALIC, self.interface.style == ITALIC
-                )
+            if self.interface.weight == BOLD:
+                native_style |= Typeface.BOLD
+            if self.interface.style in {ITALIC, OBLIQUE}:
+                native_style |= Typeface.ITALIC
+
             if native_style != typeface.getStyle():
                 typeface = Typeface.create(typeface, native_style)
 
             _FONT_CACHE[cache_key] = typeface
 
         tv.setTypeface(typeface)
-
-
-def set_bits(input, mask, enable=True):
-    if enable:
-        output = input | mask
-    else:
-        output = input & ~mask
-    return output

android/src/toga_android/widgets/selection.py

@@ -1,9 +1,9 @@
 from travertino.size import at_least
 
 from ..libs.android import R__layout
-from ..libs.android.view import Gravity, View__MeasureSpec
+from ..libs.android.view import View__MeasureSpec
 from ..libs.android.widget import ArrayAdapter, OnItemSelectedListener, Spinner
-from .base import Widget, align
+from .base import Widget
 
 
 class TogaOnItemSelectedListener(OnItemSelectedListener):
@@ -89,6 +89,3 @@ def rehint(self):
         )
         self.interface.intrinsic.width = at_least(self.native.getMeasuredWidth())
         self.interface.intrinsic.height = self.native.getMeasuredHeight()
-
-    def set_alignment(self, value):
-        self.native.setGravity(Gravity.CENTER_VERTICAL | align(value))

android/tests_backend/fonts.py

@@ -0,0 +1,107 @@
+from concurrent.futures import ThreadPoolExecutor
+
+from fontTools.ttLib import TTFont
+from java import jint
+from java.lang import Integer, Long
+
+from android.graphics import Typeface
+from android.graphics.fonts import FontFamily
+from android.util import TypedValue
+from toga.fonts import (
+    BOLD,
+    ITALIC,
+    MESSAGE,
+    NORMAL,
+    OBLIQUE,
+    SMALL_CAPS,
+    SYSTEM,
+    SYSTEM_DEFAULT_FONT_SIZE,
+)
+
+SYSTEM_FONTS = {}
+nativeGetFamily = new_FontFamily = None
+
+
+def load_fontmap():
+    field = Typeface.getClass().getDeclaredField("sSystemFontMap")
+    field.setAccessible(True)
+    fontmap = field.get(None)
+
+    for name in fontmap.keySet().toArray():
+        typeface = fontmap.get(name)
+        SYSTEM_FONTS[typeface] = name
+        for native_style in [
+            Typeface.BOLD,
+            Typeface.ITALIC,
+            Typeface.BOLD | Typeface.ITALIC,
+        ]:
+            SYSTEM_FONTS[Typeface.create(typeface, native_style)] = name
+
+
+def reflect_font_methods():
+    global nativeGetFamily, new_FontFamily
+
+    # Bypass non-SDK interface restrictions by looking them up on a background thread
+    # with no Java stack frames (https://stackoverflow.com/a/61600526).
+    with ThreadPoolExecutor() as executor:
+        nativeGetFamily = executor.submit(
+            Typeface.getClass().getDeclaredMethod,
+            "nativeGetFamily",
+            Long.TYPE,
+            Integer.TYPE,
+        ).result()
+        nativeGetFamily.setAccessible(True)
+
+        new_FontFamily = executor.submit(
+            FontFamily.getClass().getConstructor, Long.TYPE
+        ).result()
+
+
+class FontMixin:
+    supports_custom_fonts = True
+
+    def assert_font_options(self, weight=NORMAL, style=NORMAL, variant=NORMAL):
+        assert (BOLD if self.typeface.isBold() else NORMAL) == weight
+
+        if style == OBLIQUE:
+            print("Interpreting OBLIQUE font as ITALIC")
+            assert self.typeface.isItalic()
+        else:
+            assert (ITALIC if self.typeface.isItalic() else NORMAL) == style
+
+        if variant == SMALL_CAPS:
+            print("Ignoring SMALL CAPS font test")
+        else:
+            assert NORMAL == variant
+
+    def assert_font_size(self, expected):
+        if expected == SYSTEM_DEFAULT_FONT_SIZE:
+            expected = self.default_font_size
+        assert round(self.text_size) == round(
+            TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_SP,
+                expected,
+                self.native.getResources().getDisplayMetrics(),
+            )
+        )
+
+    def assert_font_family(self, expected):
+        if not SYSTEM_FONTS:
+            load_fontmap()
+
+        if actual := SYSTEM_FONTS.get(self.typeface):
+            assert actual == {
+                SYSTEM: self.default_font_family,
+                MESSAGE: "sans-serif",
+            }.get(expected, expected)
+        else:
+            if not nativeGetFamily:
+                reflect_font_methods()
+            family_ptr = nativeGetFamily.invoke(
+                None, self.typeface.native_instance, jint(0)
+            )
+            family = new_FontFamily.newInstance(family_ptr)
+            assert family.getSize() == 1
+
+            font = TTFont(family.getFont(0).getFile().getPath())
+            assert font["name"].getDebugName(1) == expected

android/tests_backend/probe.py

@@ -1,16 +1,7 @@
 import asyncio
 
-from toga.fonts import SYSTEM
-
 
 class BaseProbe:
-    def assert_font_family(self, expected):
-        actual = self.font.family
-        if expected == SYSTEM:
-            assert actual == "sans-serif"
-        else:
-            assert actual == expected
-
     async def redraw(self, message=None, delay=None):
         """Request a redraw of the app, waiting until that redraw has completed."""
         # If we're running slow, wait for a second

android/tests_backend/widgets/base.py

@@ -20,6 +20,7 @@
 from toga.colors import TRANSPARENT
 from toga.style.pack import JUSTIFY, LEFT
 
+from ..fonts import FontMixin
 from ..probe import BaseProbe
 from .properties import toga_color, toga_vertical_alignment
 
@@ -33,11 +34,15 @@ def onGlobalLayout(self):
         self.event.set()
 
 
-class SimpleProbe(BaseProbe):
+class SimpleProbe(BaseProbe, FontMixin):
+    default_font_family = "sans-serif"
+    default_font_size = 14
+
     def __init__(self, widget):
         super().__init__()
         self.app = widget.app
         self.widget = widget
+        self.impl = widget._impl
         self.native = widget._impl.native
         self.layout_listener = LayoutListener()
         self.native.getViewTreeObserver().addOnGlobalLayoutListener(

android/tests_backend/widgets/button.py

@@ -1,7 +1,6 @@
 from java import jclass
 
 from toga.colors import TRANSPARENT
-from toga.fonts import SYSTEM
 
 from .label import LabelProbe
 
@@ -10,12 +9,8 @@
 class ButtonProbe(LabelProbe):
     native_class = jclass("android.widget.Button")
 
-    def assert_font_family(self, expected):
-        actual = self.font.family
-        if expected == SYSTEM:
-            assert actual == "sans-serif-medium"
-        else:
-            assert actual == expected
+    # Heavier than sans-serif, but lighter than sans-serif bold
+    default_font_family = "sans-serif-medium"
 
     @property
     def background_color(self):

android/tests_backend/widgets/label.py

@@ -3,7 +3,7 @@
 from android.os import Build
 
 from .base import SimpleProbe
-from .properties import toga_alignment, toga_color, toga_font
+from .properties import toga_alignment, toga_color
 
 
 class LabelProbe(SimpleProbe):
@@ -19,12 +19,12 @@ def text(self):
         return str(self.native.getText())
 
     @property
-    def font(self):
-        return toga_font(
-            self.native.getTypeface(),
-            self.native.getTextSize(),
-            self.native.getResources(),
-        )
+    def typeface(self):
+        return self.native.getTypeface()
+
+    @property
+    def text_size(self):
+        return self.native.getTextSize()
 
     @property
     def alignment(self):

android/tests_backend/widgets/passwordinput.py

@@ -1,13 +1,5 @@
-from toga.fonts import SYSTEM
-
 from .textinput import TextInputProbe
 
 
 class PasswordInputProbe(TextInputProbe):
-    # In password mode, the EditText defaults to monospace.
-    def assert_font_family(self, expected):
-        actual = self.font.family
-        if expected == SYSTEM:
-            assert actual == "monospace"
-        else:
-            assert actual == expected
+    default_font_family = "monospace"