Typeface — qu’est-ce que c’est, types de polices et travail dans Android

Qu’est-ce que Typeface ?

Typeface — est une classe Android qui encapsule les informations de police : sa famille (Roboto, Arial, Serif) et les modificateurs de style (bold, italic). Contrairement à UIFont dans iOS, Typeface ne contient pas d’informations de taille — la taille du texte est définie séparément via la propriété textSize dans TextView ou TextStyle dans Spannable. Typeface est responsable uniquement du style et de la famille de police.

La classe est disponible à tous les niveaux d’API. Avant Android 4.4, Typeface ne prenait en charge qu’un ensemble limité de polices système : DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. À partir d’Android 8.0 (API 26), la prise en charge du chargement de polices personnalisées via des ressources XML a été ajoutée, et Android 10 a ajouté la prise en charge des polices variables.

Constantes Typeface intégrées

Android fournit plusieurs instances Typeface intégrées : Typeface.DEFAULT — police système Roboto (Material) ou Noto (AOSP), DEFAULT_BOLD — version grasse, MONOSPACE — police à chasse fixe pour le code, SERIF — police avec empattement (Noto Serif), SANS_SERIF — sans empattement (Noto Sans). Ces constantes sont disponibles sans contexte et ne nécessitent pas d’autorisations de lecture de fichiers.

Typeface dans le système

Le système Android utilise Typeface pour afficher tout le texte, y compris l’interface système, les titres, les légendes et les notifications. Chaque application peut remplacer la police par défaut via un thème (android:fontFamily) ou par programmation via setTypeface(). Typeface s’applique à tous les composants hérités de TextView : boutons, EditText et vues personnalisées.

Créer Typeface à partir de ressources

Android 8.0+ permet d’ajouter des polices à res/font et de les utiliser via des ressources XML. Le fichier de police (TTF ou OTF) est placé dans res/font, après quoi une référence R.font.font_name est créée. Typeface est chargé via ResourcesCompat.getFont(context, R.font.font_name). Cette méthode est préférable car la police est compilée dans l’APK et prend en charge les systèmes de construction ProGuard.

L’approche par ressources prend également en charge les familles de polices via un fichier XML dans res/font : vous pouvez spécifier plusieurs fichiers pour différents styles (regular, bold, italic) et le système sélectionnera automatiquement le fichier approprié lors de l’appel de setTypeface. Cela simplifie la typographie — il suffit de définir fontFamily dans le thème, et Android choisira automatiquement le bon fichier.

Utilisation de Typeface.create

La méthode Typeface.create(Typeface family, int style) crée une instance de police avec la famille et le style spécifiés. Si la famille possède déjà le style demandé, l’instance existante est retournée. Si le style est manquant, Android le synthétise — en appliquant du faux gras ou de l’italique artificiel à la police de 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

Le faux gras synthétisé peut sembler de mauvaise qualité sur les polices fines. Pour de meilleurs résultats, utilisez un fichier de police avec un vrai style gras. Typeface.create() avec un style inexistant ne lève pas d’exception, mais retourne la variante disponible la plus proche.

Typeface à partir de fichier et assets

Pour charger Typeface depuis les assets, utilisez Typeface.createFromAsset(assetManager, path). La police est placée dans le répertoire src/main/assets/fonts/, et le chemin est spécifié relativement aux assets. Cette méthode fonctionne sur toutes les versions d’Android, mais ne prend pas en charge les familles de polices et nécessite de spécifier un fichier concret pour chaque style.

La méthode Typeface.createFromFile(File) charge une police à partir d’un fichier quelconque sur le système de fichiers. Ceci est utile pour les polices téléchargées depuis le réseau ou copiées dans le stockage interne de l’application. createFromFile ne nécessite pas non plus de contexte, ce qui est pratique pour les tâches en arrière-plan, mais le fichier doit être lisible.

Chargement depuis les assets avec mise en cache

Charger Typeface à plusieurs reprises depuis les assets via createFromAsset peut entraîner la création d’objets en double. Chaque appel createFromAsset recharge le fichier. Il est recommandé d’implémenter un cache Typeface à l’aide d’une HashMap, où la clé est le chemin du fichier et la valeur est l’instance chargée. Ceci est particulièrement pertinent pour les listes avec différents types de polices.

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

Un cache en mémoire garantit qu’une police est chargée une seule fois par session d’application. Lors des changements de configuration (rotation de l’écran), le cache persiste car il réside dans un objet companion. Pour vider le cache en cas de manque de mémoire, utilisez WeakHashMap ou écoutez onTrimMemory.

Appliquer Typeface à TextView

Typeface est appliqué à TextView via la méthode setTypeface(Typeface tf) ou setTypeface(Typeface tf, int style). La deuxième variante permet de modifier le style (bold/italic) par rapport à la police actuelle. En XML, l’attribut android:fontFamily est utilisé avec une référence à la police ou à la famille système. Pour une configuration programmatique, appeler setTypeface(monospaceTypeface) remplace la police par celle spécifiée.

Typeface affecte tout le texte du TextView. Si différentes polices sont nécessaires sur une seule ligne, utilisez SpannableString avec TypefaceSpan. TypefaceSpan accepte Typeface ou une famille et est appliqué à une plage de caractères. C’est la seule façon de mélanger les polices à l’intérieur d’un seul TextView sans composants imbriqués.

TypefaceSpan pour du texte partiel

Appliquez TypefaceSpan uniquement à une partie de la chaîne. Par exemple, la valeur d’une variable dans le texte doit être en police à chasse fixe tandis que le reste du texte reste en police système. Créez un SpannableString et définissez un TypefaceSpan avec Typeface MONOSPACE sur la plage souhaitée. Le reste du texte conserve la police TextView d’origine.

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

Le texte « variableName » apparaîtra en police à chasse fixe bleue, tandis que le mot « Code : » reste en police système. TypefaceSpan peut être combiné avec n’importe quel autre span pour un contrôle précis sur chaque segment de texte.

Polices personnalisées via Typeface

Android prend en charge plusieurs formats de police : TrueType (TTF), OpenType (OTF) et Web Open Font Format (WOFF2) à partir d’Android 10. TTF et OTF sont les principaux formats pour les polices personnalisées. Les polices XML (Font Family) ne sont pas un format séparé, mais servent de description du fichier à utiliser pour chaque style.

Pour utiliser une police personnalisée via res/font, créez un fichier XML de famille spécifiant les chemins vers les fichiers de police pour regular, bold et italic. Ensuite, dans le thème de l’application, spécifiez android:fontFamily="@font/custom_family". Toutes les instances de TextView utilisant ce thème obtiendront automatiquement le style correct pour chaque variante.

Chargement des polices téléchargées

Si une police est téléchargée depuis le réseau, enregistrez-la dans filesDir ou cacheDir et chargez-la via Typeface.createFromFile. Après le chargement, mettez à jour le Typeface dans TextView. Pour un chargement asynchrone, utilisez coroutine ou DownloadManager, et après la fin, publiez dans le thread UI via Handler. C’est un scénario typique pour les applications avec typographie personnalisée chargée à la demande.

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

Avant le chargement, vérifiez la disponibilité du fichier : si le fichier est corrompu ou invalide, Typeface.createFromFile lance une RuntimeException. Il est recommandé d’encadrer l’appel par try-catch et de revenir à la police système par défaut en cas d’erreur.

Typeface dans Jetpack Compose

Dans Jetpack Compose, le Typeface du SDK Android n’est pas utilisé directement. À la place, Compose fournit FontFamily et FontWeight pour la typographie. FontFamily est chargé via Font.Resource et Font.File. Le système typographique de Compose est défini via MaterialTheme.typography, où chaque style (h1, body1, button) peut se voir attribuer une FontFamily personnalisée.

Pour charger une police depuis les ressources, Compose utilise Font(R.font.font_name, weight, style). Une police depuis les assets est chargée via Font(assetPath = "fonts/custom.otf", weight, style). Après avoir défini la police, elle est transmise à Typography, puis appliquée via MaterialTheme.typography.bodyLarge et les styles similaires.

Conversion de Typeface en police Compose

Si vous avez un Typeface existant créé via le SDK Android, il peut être utilisé dans Compose via TypefaceAdapter ou en créant une FontFamily basée sur Typeface. Obtenez le Typeface depuis Typeface.create et transmettez-le à FontFamily.Custom(listOf(Font(typeface))). Cependant, l’approche native avec Font.Resource est recommandée car elle est mieux optimisée pour Compose.

Performances et mise en cache

Charger des polices à partir de fichiers est une opération potentiellement coûteuse. Chaque appel à Typeface.createFromAsset ou Typeface.createFromFile lit le fichier depuis le disque, l’analyse et crée un objet Typeface. Pour les polices de 1 à 2 Mo, cela prend 10 à 50 ms au démarrage à froid. La mise en cache de Typeface est une pratique obligatoire pour les applications avec des polices personnalisées.

Le SDK Android ne met pas en cache les polices créées via createFromAsset ou createFromFile. Contrairement aux polices système, qui sont préchargées dans le processus Zygote, les polices personnalisées sont chargées à chaque accès. Il est recommandé d’utiliser LruCache ou ConcurrentHashMap avec un identifiant de police comme clé. Une taille de cache de 10 à 20 instances couvre l’ensemble typique de polices d’une application.

Optimisation via Font Family (API 26+)

Android 8.0+ optimise le chargement des polices via XML Font Family. En spécifiant android:fontFamily="@font/my_family" dans la mise en page XML, Android charge la police paresseusement — uniquement lorsque le composant devient visible. Le système met également en cache les polices chargées via ResourcesCompat.getFont() dans un cache global de processus. Cela rend l’approche par ressources la plus performante.

Typeface dans RecyclerView

Lors de l’utilisation de Typeface dans les adaptateurs RecyclerView, il est important de ne pas charger la police dans la méthode onBindViewHolder. Effectuez le chargement une fois lors de la création de l’adaptateur ou utilisez un ViewHolder avec Typeface préchargé. Si chaque élément de la liste nécessite une police unique, implémentez un cache à l’aide de WeakHashMap et videz-le lors du défilement au-delà des positions visibles pour économiser de la mémoire.