Typeface — mi ez, betűtípus típusok és munka Androidban

Mi az a Typeface?

Typeface — egy Android osztály, amely a betűtípus információit kapszulába zárja: családját (Roboto, Arial, Serif) és stílusmódosítóit (vastagság, dőlt). Az iOS UIFont-jával ellentétben a Typeface nem tartalmaz méretinformációt — a szöveg méretét külön állítjuk be a textSize tulajdonsággal TextView-ban vagy TextStyle-lel Spannable-ben. A Typeface csak a betűtípus kinézetéért és garnitúrájáért felelős.

Az osztály minden API szinten elérhető. Android 4.4-ig a Typeface csak korlátozott rendszerbetűtípus-készletet támogatott: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. Android 8.0-tól (API 26) kezdve megjelent az egyedi betűtípusok XML erőforrásokon keresztül történő betöltésének támogatása, és az Android 10 hozzáadta a változó betűtípusok támogatását.

Beépített Typeface állandók

Az Android számos beépített Typeface példányt kínál: Typeface.DEFAULT — rendszerbetűtípus Roboto (Material) vagy Noto (AOSP), DEFAULT_BOLD — vastag változat, MONOSPACE — monospace betűtípus kódhoz, SERIF — talpas betűtípus (Noto Serif), SANS_SERIF — talpatlan betűtípus (Noto Sans). Ezek az állandók kontextus nélkül elérhetők, és nem igényelnek fájlolvasási engedélyeket.

Typeface a rendszerben

Az Android rendszer a Typeface-t használja az összes szöveg megjelenítéséhez, beleértve a rendszer UI-t, címeket, címkéket és értesítéseket. Minden alkalmazás felülírhatja az alapértelmezett betűtípust téma (android:fontFamily) vagy programozottan setTypeface() segítségével. A Typeface minden TextView-ból származó komponensre érvényes: gombokra, EditText-re és egyedi nézetekre.

Typeface létrehozása erőforrásokból

Az Android 8.0+ lehetővé teszi betűtípusok hozzáadását a res/font mappához és használatukat XML erőforrásokon keresztül. A betűtípusfájlt (TTF vagy OTF) a res/font mappába helyezzük, majd létrehozzuk az R.font.font_name hivatkozást. A Typeface a ResourcesCompat.getFont(context, R.font.font_name) segítségével töltődik be. Ez a módszer előnyösebb, mert a betűtípus az APK-ba fordítódik és támogatja a ProGuard elrendezési rendszereket.

Az erőforrás-alapú módszer támogatja a betűtípuscsaládokat (font family) is XML fájlon keresztül a res/font mappában: több fájl is megadható különböző kinézetekhez (regular, bold, italic), és a rendszer automatikusan kiválasztja a megfelelő fájlt a setTypeface hívásakor. Ez leegyszerűsíti a tipográfiát — elég beállítani a fontFamily-t a témában, és az Android kiválasztja a megfelelő fájlt.

Typeface.create létrehozása

A Typeface.create(Typeface family, int style) metódus betűtípus-példányt hoz létre a megadott családdal és stílussal. Ha a család már rendelkezik a kért stílussal, a meglévő példány kerül visszaadásra. Ha a stílus nem létezik, az Android szintetizálja — hamis vastagítást vagy mesterséges dőltést alkalmaz az alap betűtípusra.

val boldTypeface = Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD)
val italicTypeface = Typeface.create(Typeface.MONOSPACE, Typeface.ITALIC)
val customTypeface = ResourcesCompat.getFont(context, R.font.montserrat_regular)
textView.typeface = boldTypeface

A szintetizált pszeudo-vastagítás gyenge minőségű lehet vékony betűtípusokon. Jobb eredmény érdekében használjon valódi bold kinézettel rendelkező betűtípusfájlt. A Typeface.create() nem létező stílussal nem dob kivételt, hanem a legközelebbi elérhető változatot adja vissza.

Typeface fájlból és assets-ből

A Typeface assets-ből történő betöltéséhez a Typeface.createFromAsset(assetManager, path) függvényt használjuk. A betűtípus a src/main/assets/fonts/ könyvtárba kerül, az útvonalat pedig az assets-hez képest adjuk meg. Ez a módszer az Android összes verzióján működik, de nem támogatja a betűtípuscsaládokat és megköveteli a konkrét fájl megadását minden kinézethez.

A Typeface.createFromFile(File) metódus a fájlrendszer bármely fájljából betölt betűtípust. Ez hasznos a hálózatról letöltött vagy az alkalmazás belső tárába másolt betűtípusokhoz. A createFromFile nem igényel kontextust, ami kényelmes háttérfeladatokhoz, de a fájlnak olvashatónak kell lennie.

Betöltés assets-ből gyorsítótárral

A Typeface többszöri betöltése assets-ből a createFromAsset segítségével duplikált objektumok létrehozásához vezethet. Minden createFromAsset hívás újratölti a fájlt. Javasolt egy Typeface gyorsítótár megvalósítása HashMap segítségével, ahol a kulcs a fájl útvonala, az érték pedig a betöltött példány. Ez különösen fontos a különböző betűtípusú listák esetében.

object TypefaceCache {
    private val cache = mutableMapOf<String, Typeface>()
    fun getTypeface(context: Context, filename: String): Typeface {
        return cache.getOrPut(filename) {
            Typeface.createFromAsset(context.assets, "fonts/$filename")
        }
    }
}
// Használat
val typeface = TypefaceCache.getTypeface(context, "Roboto-Bold.ttf")

A memóriában tárolt gyorsítótár biztosítja, hogy egy betűtípus csak egyszer töltődjön be alkalmazás-munkamenetenként. Konfigurációváltáskor (képernyőelforgatás) a gyorsítótár megmarad, mert a companion objektumban található. Memóriahiány esetén a gyorsítótár tisztításához használjon WeakHashMap-ot vagy figyelje az onTrimMemory-t.

Typeface alkalmazása TextView-ra

A Typeface-t a TextView-ra a setTypeface(Typeface tf) vagy setTypeface(Typeface tf, int style) metódussal alkalmazzuk. A második variáció lehetővé teszi a stílus (bold/italic) megváltoztatását az aktuális betűtípushoz képest. XML-ben az android:fontFamily attribútumot használjuk a betűtípusra vagy rendszercsaládra hivatkozva. Programozott beállításhoz a setTypeface(monospaceTypeface) hívás lecseréli a betűtípust a megadottra.

A Typeface az egész TextView szövegre hat. Ha egy sorban eltérő betűtípusra van szükség, SpannableString-et használunk TypefaceSpan-nel. A TypefaceSpan Typeface-t vagy family-t fogad el, és egy karaktertartományra alkalmazzuk. Ez az egyetlen mód a betűtípusok keverésére egy TextView-n belül, beágyazott komponensek nélkül.

TypefaceSpan a szöveg egy részéhez

Alkalmazza a TypefaceSpan-t csak a sztring egy részére. Például a változó értékének a szövegben monospace betűtípussal kell megjelennie, a többi szövegnek pedig rendszerbetűtípussal. Létrehozunk egy SpannableString-et, és a kívánt tartományra beállítjuk a TypefaceSpan-t MONOSPACE Typeface-szel. A szöveg többi része az eredeti TextView betűtípussal marad.

val text = "Code: variableName"
val spannable = SpannableString(text)
spannable.setSpan(
    TypefaceSpan(Typeface.MONOSPACE),
    5, text.length, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
)
spannable.setSpan(
    ForegroundColorSpan(Color.BLUE),
    5, text.length, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
)
textView.text = spannable

A „variableName“ szöveg monospace betűtípussal, kék színben jelenik meg, a „Kod:” szó pedig rendszerbetűtípussal marad. A TypefaceSpan bármely más span-nal kombinálható a szöveg minden részének pontos szabályozásához.

Egyedi betűtípusok Typeface-en keresztül

Az Android több betűtípusformátumot támogat: TrueType (TTF), OpenType (OTF) és Web Open Font Format (WOFF2) Android 10-től. A TTF és OTF a fő formátumok az egyedi betűtípusokhoz. Az XML betűtípusok (Font Family) nem külön formátumok, hanem leírásként szolgálnak arról, hogy melyik fájlt használjuk az egyes kinézetekhez.

Az egyedi betűtípus res/font-on keresztül történő használatához hozzon létre egy XML családfájlt, amely megadja a betűtípusfájlok útvonalát a regular, bold és italic számára. Ezután az alkalmazás témájában állítsa be android:fontFamily="@font/custom_family" értéket. Az összes TextView, amely ezt a témát használja, automatikusan megkapja a megfelelő kinézetet minden stílushoz.

Letöltött betűtípusok betöltése

Ha a betűtípus a hálózatról töltődik le, mentse el a filesDir vagy cacheDir könyvtárba, és töltse be a Typeface.createFromFile segítségével. Betöltés után frissítse a Typeface-t a TextView-ban. Aszinkron betöltéshez használjon coroutine-t vagy DownloadManager-t, és befejezés után küldje el a UI szálra Handler segítségével. Ez tipikus forgatókönyv az igény szerint betöltött egyedi tipográfiával rendelkező alkalmazásoknál.

// Betűtípusfájl mentése belső tárba
val fontFile = File(context.cacheDir, "downloaded-font.otf")
fontFile.outputStream().use { output ->
    // bemeneti adatfolyam a hálózatról
    inputStream.copyTo(output)
}
// Typeface létrehozása fájlból
val downloadedTypeface = Typeface.createFromFile(fontFile)
textView.typeface = downloadedTypeface

Betöltés előtt ellenőrizze a fájl elérhetőségét: ha a fájl sérült vagy érvénytelen, a Typeface.createFromFile RuntimeException-t dob. Javasolt a hívást try-catch blokkba helyezni, és hiba esetén megtartani az alapértelmezett rendszerbetűtípust.

Typeface a Jetpack Compose-ban

A Jetpack Compose-ban a Typeface Android SDK nem használható közvetlenül. Ehelyett a Compose FontFamily és FontWeight elemeket kínál a tipográfiához. A FontFamily a Font.Resource és Font.File segítségével töltődik be. A Compose tipográfiai rendszere a MaterialTheme.typography-n keresztül állítható be, ahol minden stílushoz (h1, body1, button) egyedi FontFamily rendelhető.

A resources-ból történő betűtípus-betöltéshez a Compose a Font(R.font.font_name, weight, style) függvényt használja. Az assets-ből származó betűtípus a Font(assetPath = "fonts/custom.otf", weight, style) segítségével töltődik be. A betűtípus meghatározása után a Typography-ba kerül, majd a MaterialTheme.typography.bodyLarge és hasonló stílusokon keresztül alkalmazzuk.

Typeface konvertálása Compose betűtípussá

Ha létezik egy Android SDK-n keresztül létrehozott Typeface, használható Compose-ban TypefaceAdapter-en keresztül vagy Typeface alapú FontFamily létrehozásával. Ehhez vegye ki a Typeface-t a Typeface.create-ból, és adja át a FontFamily.Custom(listOf(Font(typeface))) függvénynek. Azonban javasolt a natív megközelítés használata Font.Resource-val, mivel az jobban optimalizált a Compose számára.

Teljesítmény és gyorsítótár

A betűtípusok fájlokból történő betöltése potenciálisan költséges művelet. Minden Typeface.createFromAsset vagy Typeface.createFromFile hívás beolvassa a fájlt a lemezről, elemzi és Typeface objektumot hoz létre. 1-2 MB méretű betűtípusok esetén ez 10-50 ms-ig tarthat hideg induláskor. A Typeface gyorsítótárazása kötelező gyakorlat az egyedi betűtípusokkal rendelkező alkalmazásoknál.

Az Android SDK nem gyorsítótárazza a createFromAsset vagy createFromFile útján létrehozott betűtípusokat. Ellentétben a rendszerbetűtípusokkal, amelyek előre be vannak töltve a Zygote folyamatban, az egyedi betűtípusok minden hozzáféréskor betöltődnek. Javasolt LruCache vagy ConcurrentHashMap használata a betűtípus-azonosítóból származó kulccsal. A gyorsítótár mérete — 10-20 példány, ami lefedi az alkalmazás tipikus betűtípuskészletét.

Optimalizálás Font Family (API 26+) segítségével

Az Android 8.0+ optimalizálja a betűtípusok betöltését a XML Font Family segítségével. Az android:fontFamily="@font/my_family" megadásakor az XML elrendezésben az Android lustán tölti be a betűtípust — csak akkor, amikor a komponens láthatóvá válik. A rendszer a ResourcesCompat.getFont() útján betöltött betűtípusokat is gyorsítótárazza a folyamat globális gyorsítótárában. Ez teszi az erőforrás-alapú módszert a legteljesítményesebbé.

Typeface a RecyclerView-ban

A Typeface használatakor a RecyclerView adapterekben fontos, hogy ne töltse be a betűtípust az onBindViewHolder metódusban. Hívja meg a betöltést egyszer az adapter létrehozásakor, vagy használjon ViewHolder-t előre betöltött Typeface-szel. Ha a lista minden eleme egyedi betűtípust igényel, valósítson meg egy gyorsítótárat WeakHashMap segítségével, és tisztítsa meg a látható pozíciókon túl görgetéskor a memória megtakarítása érdekében.