Typeface — wat is het, soorten lettertypen en werken in Android

Wat is Typeface?

Typeface — is een Android klasse die informatie over het lettertype inkapselt: de familie (Roboto, Arial, Serif) en stijlaanpassingen (vet, cursief). In tegenstelling tot UIFont in iOS bevat Typeface geen informatie over de grootte — de tekstgrootte wordt apart ingesteld via de eigenschap textSize in TextView of TextStyle in Spannable. Typeface is alleen verantwoordelijk voor het uiterlijk en de garnituur van het lettertype.

De klasse is beschikbaar op alle API-niveaus. Tot Android 4.4 ondersteunde Typeface slechts een beperkte set systeemlettertypen: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. Vanaf Android 8.0 (API 26) kwam ondersteuning voor het laden van aangepaste lettertypen via XML-bronnen, en Android 10 voegde ondersteuning voor variabele lettertypen toe.

Ingebouwde Typeface constanten

Android biedt verschillende ingebouwde Typeface-instanties: Typeface.DEFAULT — systeemlettertype Roboto (Material) of Noto (AOSP), DEFAULT_BOLD — vette versie, MONOSPACE — monospace lettertype voor code, SERIF — lettertype met schreven (Noto Serif), SANS_SERIF — schreefloos lettertype (Noto Sans). Deze constanten zijn beschikbaar zonder context en vereisen geen leesrechten voor bestanden.

Typeface in het systeem

Het Android-systeem gebruikt Typeface voor het weergeven van alle tekst, inclusief systeem-UI, koppen, labels en meldingen. Elke applicatie kan het standaardlettertype overschrijven via thema (android:fontFamily) of programmatisch via setTypeface(). Typeface wordt toegepast op alle componenten die overerven van TextView: knoppen, EditText en aangepaste weergaven.

Typeface maken uit bronnen

Android 8.0+ maakt het mogelijk lettertypen toe te voegen aan res/font en ze te gebruiken via XML-bronnen. Het lettertypebestand (TTF of OTF) wordt in res/font geplaatst, waarna een verwijzing R.font.font_name wordt gemaakt. Typeface wordt geladen via ResourcesCompat.getFont(context, R.font.font_name). Deze methode heeft de voorkeur omdat het lettertype wordt gecompileerd in de APK en ProGuard-indelingssystemen ondersteunt.

De bronmethode ondersteunt ook lettertypefamilies (font family) via een XML-bestand in res/font: meerdere bestanden kunnen worden opgegeven voor verschillende weergaven (regular, bold, italic) en het systeem kiest automatisch het juiste bestand bij het aanroepen van setTypeface. Dit vereenvoudigt typografie — het is voldoende om fontFamily in het thema in te stellen en Android kiest zelf het juiste bestand.

Typeface.create maken

De methode Typeface.create(Typeface family, int style) maakt een lettertype-instantie met opgegeven familie en stijl. Als de familie de gevraagde stijl al heeft, wordt de bestaande instantie geretourneerd. Als de stijl niet bestaat, synthetiseert Android deze — het past een valse vetgedrukte of kunstmatige cursief toe op het basislettertype.

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

Pseudo-vet gesynthetiseerd kan er van slechte kwaliteit uitzien op dunne lettertypen. Gebruik voor een beter resultaat een lettertypebestand met echte bold-weergave. Typeface.create() met een niet-bestaande stijl gooit geen uitzondering, maar retourneert de dichtstbijzijnde beschikbare variant.

Typeface uit bestand en assets

Voor het laden van Typeface uit assets wordt Typeface.createFromAsset(assetManager, path) gebruikt. Het lettertype wordt geplaatst in de map src/main/assets/fonts/ en het pad wordt relatief aan assets opgegeven. Deze methode werkt op alle Android-versies, maar ondersteunt geen lettertypefamilies en vereist het opgeven van een specifiek bestand voor elke weergave.

De methode Typeface.createFromFile(File) laadt een lettertype uit een willekeurig bestand op het bestandssysteem. Dit is handig voor lettertypen die zijn gedownload van het netwerk of gekopieerd naar de interne opslag van de applicatie. createFromFile vereist ook geen context, wat handig is voor achtergrondtaken, maar het bestand moet leesbaar zijn.

Laden uit assets met caching

Herhaaldelijk laden van Typeface uit assets via createFromAsset kan leiden tot het maken van gedupliceerde objecten. Elke createFromAsset-aanroep laadt het bestand opnieuw. Het wordt aanbevolen een Typeface-cache te implementeren via HashMap, waarbij de sleutel het bestandspad is en de waarde de geladen instantie. Dit is vooral belangrijk voor lijsten met verschillende soorten lettertypen.

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")
        }
    }
}
// Gebruik
val typeface = TypefaceCache.getTypeface(context, "Roboto-Bold.ttf")

De cache in het geheugen garandeert dat een lettertype slechts eenmaal per applicatiesessie wordt geladen. Bij configuratiewijziging (schermrotatie) blijft de cache behouden omdat deze zich in het companion-object bevindt. Gebruik WeakHashMap voor het opschonen van de cache bij geheugentekort of luister naar onTrimMemory.

Typeface toepassen op TextView

Typeface wordt toegepast op TextView via de methode setTypeface(Typeface tf) of setTypeface(Typeface tf, int style). De tweede variant maakt het mogelijk de stijl (bold/italic) te wijzigen ten opzichte van het huidige lettertype. In XML wordt het attribuut android:fontFamily gebruikt met een verwijzing naar het lettertype of de systeemfamilie. Voor programmatische instelling vervangt de aanroep setTypeface(monospaceTypeface) het lettertype door het opgegeven lettertype.

Typeface beïnvloedt de volledige tekst van TextView. Als een ander lettertype in een enkele regel nodig is, wordt SpannableString met TypefaceSpan gebruikt. TypefaceSpan accepteert Typeface of family en wordt toegepast op een bereik van tekens. Dit is de enige manier om lettertypen te mengen binnen een enkele TextView zonder geneste componenten.

TypefaceSpan voor een deel van de tekst

Pas TypefaceSpan alleen toe op een deel van de string. De waarde van een variabele in de tekst moet bijvoorbeeld worden weergegeven met een monospace-lettertype en de rest van de tekst met het systeemlettertype. Er wordt een SpannableString gemaakt en op het gewenste bereik wordt TypefaceSpan met MONOSPACE Typeface ingesteld. De rest van de tekst blijft met het oorspronkelijke lettertype van TextView.

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

Tekst „variableName“ wordt weergegeven in monospace-lettertype in blauwe kleur en het woord „Kod:“ blijft in het systeemlettertype. TypefaceSpan kan worden gecombineerd met andere spans voor nauwkeurige controle over elk tekstfragment.

Aangepaste lettertypen via Typeface

Android ondersteunt verschillende lettertypeformaten: TrueType (TTF), OpenType (OTF) en Web Open Font Format (WOFF2) vanaf Android 10. TTF en OTF zijn de belangrijkste formaten voor aangepaste lettertypen. XML-lettertypen (Font Family) zijn geen apart formaat, maar dienen als beschrijving welk bestand voor elke weergave te gebruiken.

Voor het gebruik van een aangepast lettertype via res/font maakt u een XML-familiebestand waarin de paden naar lettertypebestanden voor regular, bold en italic worden opgegeven. Stel vervolgens in het thema van de applicatie android:fontFamily="@font/custom_family" in. Alle TextView die dit thema gebruiken, krijgen automatisch de juiste weergave voor elke stijl.

Gedownloade lettertypen laden

Als een lettertype wordt gedownload van het netwerk, sla het dan op in filesDir of cacheDir en laad het via Typeface.createFromFile. Werk na het laden Typeface bij in TextView. Gebruik voor asynchroon laden coroutine of DownloadManager en stuur na voltooiing via Handler naar de UI-thread. Dit is een typisch scenario voor applicaties met aangepaste typografie die op verzoek wordt geladen.

// Lettertypebestand opslaan in interne opslag
val fontFile = File(context.cacheDir, "downloaded-font.otf")
fontFile.outputStream().use { output ->
    // invoerstroom van netwerk
    inputStream.copyTo(output)
}
// Typeface uit bestand maken
val downloadedTypeface = Typeface.createFromFile(fontFile)
textView.typeface = downloadedTypeface

Controleer voor het laden de beschikbaarheid van het bestand: als het bestand beschadigd of ongeldig is, gooit Typeface.createFromFile een RuntimeException. Het wordt aanbevolen de aanroep in try-catch te plaatsen en bij een fout het standaard systeemlettertype te behouden.

Typeface in Jetpack Compose

In Jetpack Compose wordt Typeface Android SDK niet direct gebruikt. In plaats daarvan biedt Compose FontFamily en FontWeight voor typografie. FontFamily wordt geladen via Font.Resource en Font.File. Het typografiesysteem van Compose wordt ingesteld via MaterialTheme.typography, waar aan elke stijl (h1, body1, button) een aangepaste FontFamily kan worden toegewezen.

Voor het laden van een lettertype uit resources gebruikt Compose Font(R.font.font_name, weight, style). Een lettertype uit assets wordt geladen via Font(assetPath = "fonts/custom.otf", weight, style). Na het definiëren van het lettertype wordt het doorgegeven aan Typography en vervolgens toegepast via MaterialTheme.typography.bodyLarge en vergelijkbare stijlen.

Converteren van Typeface naar Compose-lettertype

Als er een kant-en-klare Typeface is gemaakt via Android SDK, kan deze worden gebruikt in Compose via TypefaceAdapter of door een FontFamily te maken op basis van Typeface. Hiervoor haalt u Typeface uit Typeface.create en geeft u het door aan FontFamily.Custom(listOf(Font(typeface))). Het wordt echter aanbevolen de native benadering met Font.Resource te gebruiken omdat deze beter is geoptimaliseerd voor Compose.

Prestaties en caching

Het laden van lettertypen uit bestanden is een potentieel dure operatie. Elke aanroep van Typeface.createFromAsset of Typeface.createFromFile leest het bestand van schijf, parseert het en maakt een Typeface-object. Voor lettertypen van 1-2 MB duurt dit 10-50 ms bij een koude start. Het cachen van Typeface is verplicht voor applicaties met aangepaste lettertypen.

Android SDK cached geen lettertypen die zijn gemaakt via createFromAsset of createFromFile. In tegenstelling tot systeemlettertypen die vooraf zijn geladen in het Zygote-proces, worden aangepaste lettertypen bij elke toegang geladen. Het wordt aanbevolen LruCache of ConcurrentHashMap te gebruiken met een sleutel uit de lettertype-identificatie. Cachegrootte — 10-20 instanties, wat de typische lettertypeset van de applicatie dekt.

Optimalisatie via Font Family (API 26+)

Android 8.0+ optimaliseert het laden van lettertypen via XML Font Family. Bij het instellen van android:fontFamily="@font/my_family" in XML-lay-out laadt Android het lettertype lui — alleen wanneer de component zichtbaar wordt. Het systeem cached ook lettertypen geladen via ResourcesCompat.getFont() in de globale cache van het proces. Dit maakt de bronmethode het meest performant.

Typeface in RecyclerView

Bij het gebruik van Typeface in adapters van RecyclerView is het belangrijk het lettertype niet te laden in de methode onBindViewHolder. Roep het laden eenmalig aan bij het maken van de adapter of gebruik ViewHolder met vooraf geladen Typeface. Als elk item in de lijst een uniek lettertype vereist, implementeer dan een cache via WeakHashMap en maak deze leeg bij scrollen voorbij zichtbare posities om geheugen te besparen.