ruby_everywhere 0.3.0 → 0.4.0

data/support/mobile/android/app/src/main/java/com/rubyeverywhere/shell/IconFont.kt

@@ -0,0 +1,211 @@
+package com.rubyeverywhere.shell
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.util.Log
+
+/**
+ * Material icons resolved by name, at runtime, from a bundled font.
+ *
+ * Android has no `UIImage(systemName:)`, but Google ships the Material icons as
+ * a font where each icon is a codepoint keyed by its name — so
+ * `icons.android: favorite` resolves exactly like an SF Symbol, with no
+ * drawable catalog to curate. That matters beyond tab bars: nav-bar buttons and
+ * overflow menu items take their icon names from page HTML
+ * (`data-everywhere-menu-icon-android="share"`), which only exists at runtime.
+ * A curated drawable set could never cover those. A font can.
+ *
+ * The font in `assets/fonts/` is stamped by the builder — Material Symbols
+ * (4,267 icons, variable, with a FILL axis) by default, or the bundled classic
+ * MaterialIcons-Regular (2,235 icons, 357 KB) for an offline build. This class
+ * discovers whichever one is there rather than naming it, so switching fonts is
+ * purely a build-time decision.
+ */
+object IconFont {
+
+    private const val TAG = "Everywhere"
+    private const val ASSET_DIR = "fonts"
+
+    /** Rendered when a name isn't in the font's map. */
+    private const val FALLBACK_NAME = "circle"
+
+    private data class CacheKey(val name: String, val fill: Float, val sizePx: Int)
+
+    private val bitmaps = mutableMapOf<CacheKey, Bitmap>()
+    private val typefaces = mutableMapOf<Float, Typeface?>()
+
+    private var fontAssetPath: String? = null
+    private var codepointsAssetPath: String? = null
+    private var codepoints: Map<String, Int>? = null
+
+    /**
+     * A [Drawable] for a Material icon name. Never null: an unknown name falls
+     * back to `circle`, and a font that can't be read at all falls back to a
+     * blank square of the requested size. Callers put these straight into menu
+     * items and toolbars, where a null would mean branching at every call site
+     * over a case that should fail visibly, once, in the log — not structurally.
+     *
+     * @param name the icon name, optionally suffixed `.fill` (`favorite.fill`),
+     *  mirroring the iOS `heart.fill` spelling. The suffix wins over [fill].
+     * @param sizePx the square size to rasterise at. Pass real pixels, not dp:
+     *  the bitmap is resolution-dependent in a way a vector isn't, and a wrong
+     *  density reads as blur.
+     * @param fill the FILL axis value, 0..1. Silently ignored by the classic
+     *  font, which has no `fvar` table.
+     *
+     * The returned bitmap is drawn opaque white. Every visible colour comes
+     * from the ColorStateList the host widget applies (see
+     * `res/color/bottom_navigation_item.xml`), so the same cached bitmap serves
+     * light mode, dark mode and the selected state.
+     */
+    fun drawable(context: Context, name: String, sizePx: Int, fill: Float = 0f): Drawable {
+        val size = sizePx.coerceAtLeast(1)
+        val bitmap = bitmap(context, name, size, fill) ?: blank(size)
+        return BitmapDrawable(context.resources, bitmap)
+    }
+
+    /**
+     * The same thing for callers that only ever want "outlined or filled" — a
+     * nav button or a menu row, where the `.fill` suffix has already been split
+     * off the name. The axis is continuous, but nothing in the shell has a use
+     * for 0.4 of a fill.
+     */
+    fun drawable(context: Context, name: String, sizePx: Int, fill: Boolean): Drawable =
+        drawable(context, name, sizePx, if (fill) 1f else 0f)
+
+    private fun blank(sizePx: Int): Bitmap =
+        Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.ARGB_8888)
+
+    private fun bitmap(context: Context, name: String, sizePx: Int, fill: Float): Bitmap? {
+        if (sizePx <= 0) return null
+
+        val requestedFill = if (name.endsWith(".fill")) 1f else fill.coerceIn(0f, 1f)
+        val requestedName = name.removeSuffix(".fill")
+
+        // Keyed by NAME, not codepoint: 217 Symbols codepoints are shared by
+        // two or more names, so a codepoint key would collide aliases — and
+        // `favorite` and `favorite.fill` are the same codepoint at different
+        // fills, which is the collision that would actually be visible.
+        val key = CacheKey(requestedName, requestedFill, sizePx)
+        bitmaps[key]?.let { return it }
+
+        val map = codepoints(context) ?: return null
+        val codepoint = map[requestedName]
+            ?: map[FALLBACK_NAME]
+            ?: return null
+
+        if (map[requestedName] == null) {
+            Log.w(TAG, "icon '$requestedName' is not in the bundled icon font; falling back to '$FALLBACK_NAME'")
+        }
+
+        val typeface = typeface(context, requestedFill) ?: return null
+        val rendered = render(codepoint, typeface, sizePx)
+        bitmaps[key] = rendered
+        return rendered
+    }
+
+    private fun render(codepoint: Int, typeface: Typeface, sizePx: Int): Bitmap {
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            this.typeface = typeface
+            textSize = sizePx.toFloat()
+            color = Color.WHITE
+            textAlign = Paint.Align.CENTER
+        }
+
+        val bitmap = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bitmap)
+        val metrics = paint.fontMetrics
+        val baseline = sizePx / 2f - (metrics.ascent + metrics.descent) / 2f
+
+        // Character.toChars, never `codepoint.toChar()`: 105 of the 4,267
+        // Material Symbols icons live above U+FFFF (U+FFF03–U+FFFFD) and one
+        // classic icon does too. Truncating to 16 bits renders the wrong glyph
+        // or a tofu, and does so silently.
+        canvas.drawText(String(Character.toChars(codepoint)), sizePx / 2f, baseline, paint)
+        return bitmap
+    }
+
+    private fun typeface(context: Context, fill: Float): Typeface? =
+        typefaces.getOrPut(fill) {
+            val path = fontAsset(context) ?: return@getOrPut null
+            runCatching {
+                Typeface.Builder(context.assets, path)
+                    // Ignored by a font with no `fvar` table (the classic set),
+                    // which is why `icons.android: x.fill` is rejected at build
+                    // time when `icon_font: classic` — by then it's too late to
+                    // tell the difference here.
+                    .setFontVariationSettings("'FILL' $fill, 'wght' 400, 'GRAD' 0, 'opsz' 24")
+                    .build()
+            }.getOrElse {
+                Log.w(TAG, "could not build a Typeface from $path", it)
+                runCatching { Typeface.createFromAsset(context.assets, path) }.getOrNull()
+            }
+        }
+
+    /**
+     * `name<space>hexcodepoint`, one per line, no header. The hex field is 4, 5
+     * or 6 characters wide depending on the font, so it is parsed rather than
+     * sliced.
+     */
+    private fun codepoints(context: Context): Map<String, Int>? {
+        codepoints?.let { return it }
+
+        val path = codepointsAsset(context) ?: return null
+        val parsed = runCatching {
+            context.assets.open(path).bufferedReader().useLines { lines ->
+                lines.mapNotNull { line ->
+                    val parts = line.trim().split(' ')
+                    if (parts.size != 2) return@mapNotNull null
+                    val cp = parts[1].toIntOrNull(16) ?: return@mapNotNull null
+                    if (cp <= 0 || cp > 0x10FFFF) return@mapNotNull null
+                    parts[0] to cp
+                }.toMap()
+            }
+        }.getOrElse {
+            Log.e(TAG, "could not read the icon font's codepoints from $path", it)
+            null
+        }
+
+        codepoints = parsed
+        return parsed
+    }
+
+    /**
+     * The `.ttf` and its `.codepoints` are discovered, not named. Which font is
+     * present is a build-time decision (`native.android.icon_font`), and the
+     * two files must always travel together: 282 names exist in both fonts with
+     * *different* codepoints, so a map read from the wrong file renders the
+     * wrong icons rather than failing.
+     */
+    private fun fontAsset(context: Context): String? {
+        fontAssetPath?.let { return it }
+        val name = list(context).firstOrNull { it.endsWith(".ttf", ignoreCase = true) }
+        if (name == null) {
+            Log.e(TAG, "no .ttf found in assets/$ASSET_DIR — icons will not render")
+            return null
+        }
+        return "$ASSET_DIR/$name".also { fontAssetPath = it }
+    }
+
+    private fun codepointsAsset(context: Context): String? {
+        codepointsAssetPath?.let { return it }
+        val font = fontAsset(context)?.substringAfterLast('/')?.substringBeforeLast('.')
+        val files = list(context)
+        val name = files.firstOrNull { it == "$font.codepoints" }
+            ?: files.firstOrNull { it.endsWith(".codepoints", ignoreCase = true) }
+        if (name == null) {
+            Log.e(TAG, "no .codepoints found in assets/$ASSET_DIR — icons will not render")
+            return null
+        }
+        return "$ASSET_DIR/$name".also { codepointsAssetPath = it }
+    }
+
+    private fun list(context: Context): List<String> =
+        runCatching { context.assets.list(ASSET_DIR)?.toList() }.getOrNull() ?: emptyList()
+}