Typeface — was ist das, Schriftarten und Arbeit in Android

Was ist Typeface?

Typeface — ist eine Android-Klasse, die Schriftinformationen kapselt: ihre Familie (Roboto, Arial, Serif) und Stilmodifikatoren (bold, italic). Anders als UIFont in iOS enthält Typeface keine Größeninformationen — die Textgröße wird separat über die textSize-Eigenschaft in TextView oder TextStyle in Spannable festgelegt. Typeface ist nur für die Schriftart und den Schriftschnitt verantwortlich.

Die Klasse ist auf allen API-Ebenen verfügbar. Vor Android 4.4 unterstützte Typeface nur einen begrenzten Satz von Systemschriftarten: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. Ab Android 8.0 (API 26) wurde die Unterstützung für das Laden benutzerdefinierter Schriftarten über XML-Ressourcen hinzugefügt, und Android 10 fügte Unterstützung für variable Schriftarten hinzu.

Integrierte Typeface-Konstanten

Android stellt mehrere integrierte Typeface-Instanzen bereit: Typeface.DEFAULT — Systemschriftart Roboto (Material) oder Noto (AOSP), DEFAULT_BOLD — fette Version, MONOSPACE — monospace Schriftart für Code, SERIF — Serifenschrift (Noto Serif), SANS_SERIF — serifenlose Schrift (Noto Sans). Diese Konstanten sind ohne Kontext verfügbar und erfordern keine Dateileserechte.

Typeface im System

Das Android-System verwendet Typeface zum Rendern des gesamten Textes, einschließlich System-UI, Titeln, Beschriftungen und Benachrichtigungen. Jede Anwendung kann die Standardschriftart über Theme (android:fontFamily) oder programmatisch über setTypeface() überschreiben. Typeface gilt für alle von TextView abgeleiteten Komponenten: Schaltflächen, EditText und benutzerdefinierte Ansichten.

Typeface aus Ressourcen erstellen

Android 8.0+ ermöglicht das Hinzufügen von Schriftarten zu res/font und deren Verwendung über XML-Ressourcen. Die Schriftartdatei (TTF oder OTF) wird in res/font abgelegt, wonach ein Verweis R.font.font_name erstellt wird. Typeface wird über ResourcesCompat.getFont(context, R.font.font_name) geladen. Diese Methode ist vorzuziehen, da die Schriftart in die APK kompiliert wird und ProGuard-Buildsysteme unterstützt.

Der Ressourcenansatz unterstützt auch Schriftfamilien über eine XML-Datei in res/font: Sie können mehrere Dateien für verschiedene Schriftschnitte (regular, bold, italic) angeben, und das System wählt automatisch die entsprechende Datei beim Aufruf von setTypeface aus. Dies vereinfacht die Typografie — setzen Sie einfach fontFamily im Theme, und Android wählt automatisch die richtige Datei aus.

Verwendung von Typeface.create

Die Methode Typeface.create(Typeface family, int style) erstellt eine Schriftinstanz mit der angegebenen Familie und dem Stil. Wenn die Familie bereits den angeforderten Stil hat, wird die vorhandene Instanz zurückgegeben. Fehlt der Stil, synthetisiert Android ihn — indem es Faux Bold oder künstliches Italic auf die Basisschrift anwendet.

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

Synthetisiertes Faux Bold kann bei dünnen Schriftarten von geringer Qualität aussehen. Für beste Ergebnisse verwenden Sie eine Schriftartdatei mit einem echten Bold-Schnitt. Typeface.create() mit einem nicht vorhandenen Stil wirft keine Ausnahme, sondern gibt die nächstgelegene verfügbare Variante zurück.

Typeface aus Datei und Assets

Zum Laden von Typeface aus Assets verwenden Sie Typeface.createFromAsset(assetManager, path). Die Schriftart wird im Verzeichnis src/main/assets/fonts/ abgelegt, und der Pfad wird relativ zu assets angegeben. Diese Methode funktioniert auf allen Android-Versionen, unterstützt jedoch keine Schriftfamilien und erfordert die Angabe einer bestimmten Datei für jeden Schriftschnitt.

Die Methode Typeface.createFromFile(File) lädt eine Schriftart aus einer beliebigen Datei im Dateisystem. Dies ist nützlich für Schriftarten, die aus dem Netzwerk heruntergeladen oder in den internen Speicher der App kopiert wurden. createFromFile benötigt ebenfalls keinen Kontext, was für Hintergrundaufgaben praktisch ist, aber die Datei muss lesbar sein.

Laden aus Assets mit Caching

Wiederholtes Laden von Typeface aus Assets über createFromAsset kann zur Erstellung doppelter Objekte führen. Jeder createFromAsset-Aufruf lädt die Datei erneut. Es wird empfohlen, einen Typeface-Cache mit einer HashMap zu implementieren, wobei der Schlüssel der Dateipfad und der Wert die geladene Instanz ist. Dies ist besonders relevant für Listen mit verschiedenen Schriftarten.

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

Ein Cache im Speicher stellt sicher, dass eine Schriftart nur einmal pro App-Sitzung geladen wird. Bei Konfigurationsänderungen (Bildschirmdrehung) bleibt der Cache erhalten, da er sich in einem Companion-Objekt befindet. Zum Leeren des Caches bei Speicherknappheit verwenden Sie WeakHashMap oder hören auf onTrimMemory.

Typeface auf TextView anwenden

Typeface wird auf TextView über die Methode setTypeface(Typeface tf) oder setTypeface(Typeface tf, int style) angewendet. Die zweite Variante ermöglicht die Änderung des Stils (bold/italic) relativ zur aktuellen Schriftart. In XML wird das Attribut android:fontFamily mit einem Verweis auf die Schriftart oder Systemfamilie verwendet. Für die programmatische Einstellung ersetzt der Aufruf von setTypeface(monospaceTypeface) die Schriftart durch die angegebene.

Typeface wirkt sich auf den gesamten TextView-Text aus. Wenn in einer einzelnen Zeile unterschiedliche Schriftarten benötigt werden, verwenden Sie SpannableString mit TypefaceSpan. TypefaceSpan akzeptiert Typeface oder Familie und wird auf einen Zeichenbereich angewendet. Dies ist die einzige Möglichkeit, Schriftarten innerhalb eines einzelnen TextView ohne verschachtelte Komponenten zu mischen.

TypefaceSpan für Teiltext

Wenden Sie TypefaceSpan nur auf einen Teil der Zeichenfolge an. Beispielsweise sollte ein Variablenwert im Text monospace sein, während der restliche Text in der Systemschrift bleibt. Erstellen Sie einen SpannableString und setzen Sie einen TypefaceSpan mit MONOSPACE Typeface auf den gewünschten Bereich. Der restliche Text behält die ursprüngliche TextView-Schriftart.

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

Der Text „‚variableName“ wird in blauer Monospace-Schrift angezeigt, während das Wort „‚Code:“ in der Systemschrift bleibt. TypefaceSpan kann mit beliebigen anderen Spans kombiniert werden, um jeden Textabschnitt präzise zu steuern.

Benutzerdefinierte Schriftarten über Typeface

Android unterstützt mehrere Schriftformate: TrueType (TTF), OpenType (OTF) und Web Open Font Format (WOFF2) ab Android 10. TTF und OTF sind die Hauptformate für benutzerdefinierte Schriftarten. XML-Schriftarten (Font Family) sind kein separates Format, sondern dienen als Beschreibung, welche Datei für welchen Schriftschnitt verwendet werden soll.

Um eine benutzerdefinierte Schriftart über res/font zu verwenden, erstellen Sie eine Familien-XML-Datei, die die Pfade zu den Schriftartdateien für regular, bold und italic angibt. Geben Sie dann im App-Theme android:fontFamily="@font/custom_family" an. Alle TextView-Instanzen, die dieses Theme verwenden, erhalten automatisch den korrekten Schriftschnitt für jeden Stil.

Heruntergeladene Schriftarten laden

Wenn eine Schriftart aus dem Netzwerk heruntergeladen wird, speichern Sie sie in filesDir oder cacheDir und laden Sie sie über Typeface.createFromFile. Aktualisieren Sie nach dem Laden den Typeface in TextView. Verwenden Sie für asynchrones Laden coroutine oder DownloadManager, und nach Abschluss posten Sie in den UI-Thread über Handler. Dies ist ein typisches Szenario für Apps mit benutzerdefinierter Typografie, die bei Bedarf geladen wird.

// Save font file to internal storage
val fontFile = File(context.cacheDir, "downloaded-font.otf")
fontFile.outputStream().use { output ->
    // inputStream from network
    inputStream.copyTo(output)
}
// Create Typeface from file
val downloadedTypeface = Typeface.createFromFile(fontFile)
textView.typeface = downloadedTypeface

Überprüfen Sie vor dem Laden die Verfügbarkeit der Datei: Wenn die Datei beschädigt oder ungültig ist, wirft Typeface.createFromFile eine RuntimeException. Es wird empfohlen, den Aufruf in try-catch zu packen und im Fehlerfall auf die Standardsystemschrift zurückzugreifen.

Typeface in Jetpack Compose

In Jetpack Compose wird das Typeface des Android SDK nicht direkt verwendet. Stattdessen bietet Compose FontFamily und FontWeight für die Typografie. FontFamily wird über Font.Resource und Font.File geladen. Das Typografiesystem von Compose wird über MaterialTheme.typography definiert, wobei jedem Stil (h1, body1, button) eine benutzerdefinierte FontFamily zugewiesen werden kann.

Zum Laden einer Schriftart aus Ressourcen verwendet Compose Font(R.font.font_name, weight, style). Eine Schriftart aus Assets wird über Font(assetPath = "fonts/custom.otf", weight, style) geladen. Nach der Definition wird die Schriftart an Typography übergeben und dann über MaterialTheme.typography.bodyLarge und ähnliche Stile angewendet.

Typeface in Compose-Schriftart konvertieren

Wenn Sie eine vorhandene Typeface haben, die über das Android SDK erstellt wurde, kann sie in Compose über TypefaceAdapter oder durch Erstellen einer FontFamily basierend auf Typeface verwendet werden. Holen Sie sich die Typeface von Typeface.create und übergeben Sie sie an FontFamily.Custom(listOf(Font(typeface))). Der native Ansatz mit Font.Resource wird jedoch empfohlen, da er besser für Compose optimiert ist.

Leistung und Caching

Das Laden von Schriftarten aus Dateien ist ein potenziell teurer Vorgang. Jeder Aufruf von Typeface.createFromAsset oder Typeface.createFromFile liest die Datei von der Festplatte, analysiert sie und erstellt ein Typeface-Objekt. Für Schriftarten mit 1-2 MB dauert dies 10-50 ms beim Kaltstart. Caching von Typeface ist eine obligatorische Praxis für Apps mit benutzerdefinierten Schriftarten.

Das Android SDK speichert Schriftarten, die über createFromAsset oder createFromFile erstellt wurden, nicht zwischen. Anders als Systemschriftarten, die im Zygote-Prozess vorab geladen werden, werden benutzerdefinierte Schriftarten bei jedem Zugriff geladen. Es wird empfohlen, LruCache oder ConcurrentHashMap mit einem Schriftartenkennung als Schlüssel zu verwenden. Eine Cache-Größe von 10-20 Instanzen deckt den typischen Schriftartenbestand einer App ab.

Optimierung durch Font Family (API 26+)

Android 8.0+ optimiert das Laden von Schriftarten über XML Font Family. Bei Angabe von android:fontFamily="@font/my_family" im XML-Layout lädt Android die Schriftart lazy — nur wenn die Komponente sichtbar wird. Das System speichert auch Schriftarten, die über ResourcesCompat.getFont() geladen werden, in einem globalen Prozess-Cache. Dies macht den Ressourcenansatz am leistungsfähigsten.

Typeface in RecyclerView

Bei Verwendung von Typeface in RecyclerView-Adaptern ist es wichtig, Schriftarten nicht in der onBindViewHolder-Methode zu laden. Führen Sie das Laden einmal bei der Erstellung des Adapters durch oder verwenden Sie einen ViewHolder mit vorab geladenem Typeface. Wenn jedes Listenelement eine eindeutige Schriftart erfordert, implementieren Sie einen Cache mit WeakHashMap und leeren Sie ihn beim Scrollen über sichtbare Positionen hinaus, um Speicher zu sparen.