Typeface — vad är det, typer av teckensnitt och arbete i Android

Vad är Typeface?

Typeface — är en Android-klass som kapslar in information om teckensnittet: dess familj (Roboto, Arial, Serif) och stilmodifierare (fetstil, kursiv). Till skillnad från UIFont i iOS innehåller Typeface ingen information om storlek — textstorleken ställs in separat via egenskapen textSize i TextView eller TextStyle i Spannable. Typeface ansvarar bara för teckensnittets utseende och garnityr.

Klassen är tillgänglig på alla API-nivåer. Fram till Android 4.4 stödde Typeface bara en begränsad uppsättning systemteckensnitt: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. Från och med Android 8.0 (API 26) tillkom stöd för att ladda anpassade teckensnitt via XML-resurser, och Android 10 lade till stöd för variabla teckensnitt.

Inbyggda Typeface-konstanter

Android tillhandahåller flera inbyggda Typeface-instanser: Typeface.DEFAULT — systemteckensnitt Roboto (Material) eller Noto (AOSP), DEFAULT_BOLD — fet version, MONOSPACE — monospace-teckensnitt för kod, SERIF — teckensnitt med serifer (Noto Serif), SANS_SERIF — sans-serif-teckensnitt (Noto Sans). Dessa konstanter är tillgängliga utan kontext och kräver inte filläsningsbehörigheter.

Typeface i systemet

Android-systemet använder Typeface för att rendera all text, inklusive systemets UI, rubriker, etiketter och aviseringar. Varje applikation kan åsidosätta standardteckensnittet via tema (android:fontFamily) eller programmatiskt via setTypeface(). Typeface tillämpas på alla komponenter som ärver från TextView: knappar, EditText och anpassade vyer.

Skapa Typeface från resurser

Android 8.0+ gör det möjligt att lägga till teckensnitt i res/font och använda dem via XML-resurser. Teckensnittsfilen (TTF eller OTF) placeras i res/font, varefter referensen R.font.font_name skapas. Typeface laddas via ResourcesCompat.getFont(context, R.font.font_name). Denna metod är att föredra eftersom teckensnittet kompileras in i APK och stöder ProGuards layout-system.

Resursmetoden stöder också teckensnittsfamiljer (font family) via en XML-fil i res/font: flera filer kan anges för olika utseenden (regular, bold, italic) och systemet väljer automatiskt rätt fil vid anrop av setTypeface. Detta förenklar typografin — det räcker att ställa in fontFamily i temat, och Android väljer själv rätt fil.

Skapa Typeface.create

Metoden Typeface.create(Typeface family, int style) skapar en teckensnittsinstans med angiven familj och stil. Om familjen redan har den efterfrågade stilen returneras den befintliga instansen. Om stilen inte finns syntetiserar Android den — tillämpar falsk fetstil eller artificiell kursiv på basteckensnittet.

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

Syntetiserad pseudo-fetstil kan se dålig ut på tunna teckensnitt. För bättre resultat, använd en teckensnittsfil med äkta bold-utseende. Typeface.create() med en obefintlig stil kastar inget undantag, utan returnerar närmast tillgängliga variant.

Typeface från fil och assets

För att ladda Typeface från assets används Typeface.createFromAsset(assetManager, path). Teckensnittet placeras i katalogen src/main/assets/fonts/ och sökvägen anges relativt assets. Denna metod fungerar på alla Android-versioner men stöder inte teckensnittsfamiljer och kräver att en specifik fil anges för varje utseende.

Metoden Typeface.createFromFile(File) laddar teckensnitt från en godtycklig fil på filsystemet. Detta är användbart för teckensnitt som laddats ner från nätverket eller kopierats till applikationens interna lagring. createFromFile kräver inte heller kontext, vilket är praktiskt för bakgrundsuppgifter, men filen måste vara läsbar.

Ladda från assets med cache

Upprepad inladdning av Typeface från assets via createFromAsset kan leda till skapande av duplicerade objekt. Varje anrop av createFromAsset laddar filen på nytt. Det rekommenderas att implementera en Typeface-cache via HashMap, där nyckeln är filsökvägen och värdet är den laddade instansen. Detta är särskilt viktigt för listor med olika typer av teckensnitt.

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

Cache i minnet garanterar att ett teckensnitt laddas endast en gång per applikationssession. Vid konfigurationsändring (skärmrotation) behålls cachen eftersom den finns i companion-objektet. För att rensa cachen vid minnesbrist, använd WeakHashMap eller lyssna på onTrimMemory.

Tillämpa Typeface på TextView

Typeface tillämpas på TextView via metoden setTypeface(Typeface tf) eller setTypeface(Typeface tf, int style). Den andra varianten gör det möjligt att ändra stilen (bold/italic) i förhållande till det aktuella teckensnittet. I XML används attributet android:fontFamily med en referens till teckensnittet eller systemfamiljen. För programmatisk inställning kommer anropet setTypeface(monospaceTypeface) att ersätta teckensnittet med det angivna.

Typeface påverkar hela texten i TextView. Om ett annat teckensnitt behövs på en enda rad används SpannableString med TypefaceSpan. TypefaceSpan accepterar Typeface eller family och tillämpas på ett teckenintervall. Detta är det enda sättet att blanda teckensnitt i en TextView utan nästlade komponenter.

TypefaceSpan för en del av texten

Tillämpa TypefaceSpan endast på en del av strängen. Till exempel bör värdet av en variabel i texten visas med monospace-teckensnitt och resten av texten med systemteckensnitt. En SpannableString skapas och på det önskade intervallet ställs TypefaceSpan in med MONOSPACE Typeface. Resten av texten förblir med TextViewets ursprungliga teckensnitt.

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

Texten “variableName” visas med monospace-teckensnitt i blå färg och ordet “Kod:” förblir med systemteckensnitt. TypefaceSpan kan kombineras med andra spans för exakt kontroll över varje textavsnitt.

Anpassade teckensnitt via Typeface

Android stöder flera teckensnittsformat: TrueType (TTF), OpenType (OTF) och Web Open Font Format (WOFF2) från Android 10. TTF och OTF är de huvudsakliga formaten för anpassade teckensnitt. XML-teckensnitt (Font Family) är inte ett separat format utan fungerar som en beskrivning av vilken fil som ska användas för varje utseende.

För att använda ett anpassat teckensnitt via res/font skapar du en XML-familjefil där sökvägarna till teckensnittsfilerna för regular, bold och italic anges. Ställ sedan in android:fontFamily="@font/custom_family" i applikationens tema. Alla TextView som använder detta tema får automatiskt rätt utseende för varje stil.

Ladda nedladdade teckensnitt

Om teckensnittet laddas ner från nätverket, spara det i filesDir eller cacheDir och ladda det via Typeface.createFromFile. Efter inladdning, uppdatera Typeface i TextView. För asynkron inladdning, använd coroutine eller DownloadManager, och efter slutförande, skicka till UI-tråden via Handler. Detta är ett typiskt scenario för applikationer med anpassad typografi som laddas på begäran.

// Spara teckensnittsfil i intern lagring
val fontFile = File(context.cacheDir, "downloaded-font.otf")
fontFile.outputStream().use { output ->
    // ingångsström från nätverk
    inputStream.copyTo(output)
}
// Skapa Typeface från fil
val downloadedTypeface = Typeface.createFromFile(fontFile)
textView.typeface = downloadedTypeface

Före inladdning, kontrollera filens tillgänglighet: om filen är skadad eller ogiltig, kommer Typeface.createFromFile att kasta RuntimeException. Det rekommenderas att omsluta anropet i try-catch och vid fel behålla standardteckensnittet.

Typeface i Jetpack Compose

I Jetpack Compose används Typeface Android SDK inte direkt. Istället tillhandahåller Compose FontFamily och FontWeight för typografi. FontFamily laddas via Font.Resource och Font.File. Compose-typografisystemet ställs in via MaterialTheme.typography, där varje stil (h1, body1, button) kan tilldelas en anpassad FontFamily.

För att ladda teckensnitt från resources använder Compose Font(R.font.font_name, weight, style). Teckensnitt från assets laddas via Font(assetPath = "fonts/custom.otf", weight, style). Efter att teckensnittet definierats skickas det till Typography och tillämpas sedan via MaterialTheme.typography.bodyLarge och liknande stilar.

Konvertera Typeface till Compose-teckensnitt

Om det finns ett färdigt Typeface skapat via Android SDK kan det användas i Compose via TypefaceAdapter eller genom att skapa en FontFamily baserad på Typeface. För detta, hämta Typeface från Typeface.create och skicka det till FontFamily.Custom(listOf(Font(typeface))). Det rekommenderas dock att använda den ursprungliga metoden med Font.Resource eftersom den är bättre optimerad för Compose.

Prestanda och cache

Inladdning av teckensnitt från filer är en potentiellt dyr operation. Varje anrop av Typeface.createFromAsset eller Typeface.createFromFile läser filen från disken, parsar den och skapar ett Typeface-objekt. För teckensnitt på 1-2 MB tar detta 10-50 ms vid kallstart. Caching av Typeface är obligatorisk praxis för applikationer med anpassade teckensnitt.

Android SDK cachear inte teckensnitt skapade via createFromAsset eller createFromFile. Till skillnad från systemteckensnitt som är förladdade i Zygote-processen, laddas anpassade teckensnitt vid varje åtkomst. Det rekommenderas att använda LruCache eller ConcurrentHashMap med en nyckel från teckensnittsidentifieraren. Cachestorlek — 10-20 instanser, vilket täcker applikationens typiska teckensnittsuppsättning.

Optimering via Font Family (API 26+)

Android 8.0+ optimerar inladdning av teckensnitt via XML Font Family. När android:fontFamily="@font/my_family" anges i XML-layouten laddar Android teckensnittet lat — endast när komponenten blir synlig. Systemet cachear även teckensnitt laddade via ResourcesCompat.getFont() i processens globala cache. Detta gör resursmetoden mest prestandaeffektiv.

Typeface i RecyclerView

När du använder Typeface i RecyclerView-adaptrar är det viktigt att inte ladda teckensnittet i metoden onBindViewHolder. Anropa inladdningen en gång vid skapande av adaptern eller använd ViewHolder med förladdat Typeface. Om varje listobjekt kräver ett unikt teckensnitt, implementera en cache via WeakHashMap och rensa den vid rullning förbi synliga positioner för att spara minne.