Typeface — cos’è, tipi di carattere e lavoro in Android

Cos’è Typeface?

Typeface — è una classe Android che incapsula le informazioni sul carattere: la sua famiglia (Roboto, Arial, Serif) e i modificatori di stile (bold, italic). A differenza di UIFont in iOS, Typeface non contiene informazioni sulla dimensione — la dimensione del testo viene impostata separatamente tramite la proprietà textSize in TextView o TextStyle in Spannable. Typeface è responsabile solo del disegno e della famiglia del carattere.

La classe è disponibile a tutti i livelli API. Prima di Android 4.4, Typeface supportava solo un insieme limitato di caratteri di sistema: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. A partire da Android 8.0 (API 26), è stato aggiunto il supporto per il caricamento di caratteri personalizzati tramite risorse XML, e Android 10 ha aggiunto il supporto per i caratteri variabili.

Costanti Typeface integrate

Android fornisce diverse istanze Typeface integrate: Typeface.DEFAULT — carattere di sistema Roboto (Material) o Noto (AOSP), DEFAULT_BOLD — versione in grassetto, MONOSPACE — carattere monospazio per codice, SERIF — carattere con grazie (Noto Serif), SANS_SERIF — sans-serif (Noto Sans). Queste costanti sono disponibili senza contesto e non richiedono autorizzazioni di lettura file.

Typeface nel sistema

Il sistema Android utilizza Typeface per renderizzare tutto il testo, inclusi UI di sistema, titoli, didascalie e notifiche. Ogni applicazione può sovrascrivere il carattere predefinito tramite tema (android:fontFamily) o a livello di codice tramite setTypeface(). Typeface si applica a tutti i componenti ereditati da TextView: pulsanti, EditText e viste personalizzate.

Creare Typeface dalle risorse

Android 8.0+ consente di aggiungere caratteri a res/font e utilizzarli tramite risorse XML. Il file del carattere (TTF o OTF) viene inserito in res/font, dopodiché viene creato un riferimento R.font.font_name. Typeface viene caricato tramite ResourcesCompat.getFont(context, R.font.font_name). Questo metodo è preferibile perché il carattere viene compilato nell’APK e supporta i sistemi di build ProGuard.

L’approccio basato sulle risorse supporta anche le famiglie di caratteri tramite un file XML in res/font: è possibile specificare più file per diversi stili (regular, bold, italic) e il sistema selezionerà automaticamente il file appropriato quando si chiama setTypeface. Ciò semplifica la tipografia — basta impostare fontFamily nel tema e Android sceglierà automaticamente il file corretto.

Utilizzo di Typeface.create

Il metodo Typeface.create(Typeface family, int style) crea un’istanza di carattere con la famiglia e lo stile specificati. Se la famiglia ha già lo stile richiesto, viene restituita l’istanza esistente. Se lo stile manca, Android lo sintetizza — applicando falso grassetto o corsivo artificiale al carattere di base.

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

Il falso grassetto sintetizzato potrebbe apparire di bassa qualità sui caratteri sottili. Per ottenere risultati migliori, utilizzare un file di carattere con un vero stile grassetto. Typeface.create() con uno stile inesistente non genera un’eccezione, ma restituisce la variante disponibile più vicina.

Typeface da file e assets

Per caricare Typeface dagli assets, utilizzare Typeface.createFromAsset(assetManager, path). Il carattere viene inserito nella directory src/main/assets/fonts/ e il percorso viene specificato relativamente agli assets. Questo metodo funziona su tutte le versioni di Android, ma non supporta le famiglie di caratteri e richiede di specificare un file concreto per ogni stile.

Il metodo Typeface.createFromFile(File) carica un carattere da un file arbitrario nel filesystem. Ciò è utile per caratteri scaricati dalla rete o copiati nell’archivio interno dell’app. createFromFile non richiede nemmeno contesto, il che è comodo per le attività in background, ma il file deve essere leggibile.

Caricamento dagli assets con caching

Caricare Typeface ripetutamente dagli assets tramite createFromAsset può portare alla creazione di oggetti duplicati. Ogni chiamata createFromAsset ricarica il file. Si consiglia di implementare una cache Typeface utilizzando una HashMap, dove la chiave è il percorso del file e il valore è l’istanza caricata. Ciò è particolarmente rilevante per gli elenchi con diversi tipi di carattere.

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")

Una cache in memoria garantisce che un carattere venga caricato una sola volta per sessione dell’app. In caso di modifiche alla configurazione (rotazione dello schermo), la cache persiste perché risiede in un oggetto companion. Per svuotare la cache in caso di poca memoria, utilizzare WeakHashMap o ascoltare onTrimMemory.

Applicare Typeface a TextView

Typeface viene applicato a TextView tramite il metodo setTypeface(Typeface tf) o setTypeface(Typeface tf, int style). La seconda variante consente di modificare lo stile (bold/italic) rispetto al carattere corrente. In XML, viene utilizzato l’attributo android:fontFamily con un riferimento al carattere o alla famiglia di sistema. Per l’impostazione programmatica, chiamare setTypeface(monospaceTypeface) sostituisce il carattere con quello specificato.

Typeface influisce sull’intero testo di TextView. Se sono necessari caratteri diversi in una singola riga, utilizzare SpannableString con TypefaceSpan. TypefaceSpan accetta Typeface o famiglia e viene applicato a un intervallo di caratteri. Questo è l’unico modo per mescolare i caratteri all’interno di un singolo TextView senza componenti annidati.

TypefaceSpan per testo parziale

Applicare TypefaceSpan solo a una parte della stringa. Ad esempio, il valore di una variabile nel testo deve essere monospazio mentre il resto del testo rimane con il carattere di sistema. Creare uno SpannableString e impostare un TypefaceSpan con Typeface MONOSPACE sull’intervallo desiderato. Il resto del testo mantiene il carattere TextView originale.

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

Il testo “variableName” verrà visualizzato in carattere monospazio blu, mentre la parola “Code:” rimane nel carattere di sistema. TypefaceSpan può essere combinato con qualsiasi altro span per un controllo preciso su ogni segmento di testo.

Caratteri personalizzati tramite Typeface

Android supporta diversi formati di carattere: TrueType (TTF), OpenType (OTF) e Web Open Font Format (WOFF2) a partire da Android 10. TTF e OTF sono i formati principali per i caratteri personalizzati. I caratteri XML (Font Family) non sono un formato separato, ma servono come descrizione di quale file utilizzare per ogni stile.

Per utilizzare un carattere personalizzato tramite res/font, creare un file XML di famiglia che specifica i percorsi dei file di carattere per regular, bold e italic. Quindi, nel tema dell’app, specificare android:fontFamily="@font/custom_family". Tutte le istanze TextView che utilizzano questo tema otterranno automaticamente lo stile corretto per ogni variante.

Caricamento di caratteri scaricati

Se un carattere viene scaricato dalla rete, salvarlo in filesDir o cacheDir e caricarlo tramite Typeface.createFromFile. Dopo il caricamento, aggiornare Typeface in TextView. Per il caricamento asincrono, utilizzare coroutine o DownloadManager e, al completamento, pubblicare nel thread UI tramite Handler. Questo è uno scenario tipico per le app con tipografia personalizzata caricata su richiesta.

// 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

Prima del caricamento, verificare la disponibilità del file: se il file è danneggiato o non valido, Typeface.createFromFile genera una RuntimeException. Si consiglia di racchiudere la chiamata in try-catch e, in caso di errore, tornare al carattere di sistema predefinito.

Typeface in Jetpack Compose

In Jetpack Compose, il Typeface dell’SDK Android non viene utilizzato direttamente. Invece, Compose fornisce FontFamily e FontWeight per la tipografia. FontFamily viene caricato tramite Font.Resource e Font.File. Il sistema tipografico di Compose è definito tramite MaterialTheme.typography, dove ogni stile (h1, body1, button) può essere assegnato a una FontFamily personalizzata.

Per caricare un carattere dalle risorse, Compose utilizza Font(R.font.font_name, weight, style). Un carattere dagli assets viene caricato tramite Font(assetPath = "fonts/custom.otf", weight, style). Dopo aver definito il carattere, viene passato a Typography, quindi applicato tramite MaterialTheme.typography.bodyLarge e stili simili.

Conversione di Typeface in carattere Compose

Se si dispone di un Typeface esistente creato tramite l’SDK Android, può essere utilizzato in Compose tramite TypefaceAdapter o creando una FontFamily basata su Typeface. Ottenere Typeface da Typeface.create e passarlo a FontFamily.Custom(listOf(Font(typeface))). Tuttavia, l’approccio nativo con Font.Resource è raccomandato perché è meglio ottimizzato per Compose.

Prestazioni e cache

Caricare caratteri dai file è un’operazione potenzialmente costosa. Ogni chiamata a Typeface.createFromAsset o Typeface.createFromFile legge il file dal disco, lo analizza e crea un oggetto Typeface. Per caratteri di 1-2 MB, ciò richiede 10-50 ms all’avvio a freddo. La memorizzazione nella cache di Typeface è una pratica obbligatoria per le app con caratteri personalizzati.

L’SDK Android non memorizza nella cache i caratteri creati tramite createFromAsset o createFromFile. A differenza dei caratteri di sistema, che vengono precaricati nel processo Zygote, i caratteri personalizzati vengono caricati a ogni accesso. Si consiglia di utilizzare LruCache o ConcurrentHashMap con un identificatore di carattere come chiave. Una dimensione della cache di 10-20 istanze copre il set tipico di caratteri di un’app.

Ottimizzazione tramite Font Family (API 26+)

Android 8.0+ ottimizza il caricamento dei caratteri tramite XML Font Family. Specificando android:fontFamily="@font/my_family" nel layout XML, Android carica il carattere in modo lazy — solo quando il componente diventa visibile. Il sistema memorizza anche nella cache i caratteri caricati tramite ResourcesCompat.getFont() in una cache globale di processo. Ciò rende l’approccio basato sulle risorse il più performante.

Typeface in RecyclerView

Quando si utilizza Typeface negli adapter RecyclerView, è importante non caricare il carattere nel metodo onBindViewHolder. Effettuare il caricamento una volta durante la creazione dell’adapter o utilizzare un ViewHolder con Typeface precaricato. Se ogni elemento dell’elenco richiede un carattere unico, implementare una cache utilizzando WeakHashMap e svuotarla durante lo scorrimento oltre le posizioni visibili per risparmiare memoria.