Typeface — qué es, tipos de fuentes y trabajo en Android

¿Qué es Typeface?

Typeface — es una clase de Android que encapsula información sobre la fuente: su familia (Roboto, Arial, Serif) y modificadores de estilo (negrita, cursiva). A diferencia de UIFont en iOS, Typeface no contiene información de tamaño — el tamaño del texto se establece por separado mediante la propiedad textSize en TextView o TextStyle en Spannable. Typeface solo es responsable del estilo y la familia tipográfica.

La clase está disponible en todos los niveles de API. Antes de Android 4.4, Typeface solo admitía un conjunto limitado de fuentes del sistema: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. A partir de Android 8.0 (API 26) se agregó soporte para cargar fuentes personalizadas mediante recursos XML, y Android 10 añadió soporte para fuentes variables.

Constantes de Typeface Integradas

Android proporciona varias instancias de Typeface integradas: Typeface.DEFAULT — fuente del sistema Roboto (Material) o Noto (AOSP), DEFAULT_BOLD — versión en negrita, MONOSPACE — fuente monoespaciada para código, SERIF — fuente con serifas (Noto Serif), SANS_SERIF — sans-serif (Noto Sans). Estas constantes están disponibles sin contexto y no requieren permisos de lectura de archivos.

Typeface en el Sistema

El sistema Android utiliza Typeface para renderizar todo el texto, incluida la interfaz del sistema, títulos, leyendas y notificaciones. Cada aplicación puede sobrescribir la fuente predeterminada mediante tema (android:fontFamily) o mediante programación con setTypeface(). Typeface se aplica a todos los componentes heredados de TextView: botones, EditText y vistas personalizadas.

Crear Typeface desde Recursos

Android 8.0+ permite agregar fuentes a res/font y usarlas mediante recursos XML. El archivo de fuente (TTF u OTF) se coloca en res/font, después de lo cual se crea una referencia R.font.font_name. Typeface se carga mediante ResourcesCompat.getFont(context, R.font.font_name). Este método es preferible porque la fuente se compila en el APK y es compatible con los sistemas de compilación ProGuard.

El enfoque de recursos también admite familias de fuentes mediante un archivo XML en res/font: puede especificar varios archivos para diferentes estilos (regular, bold, italic) y el sistema seleccionará automáticamente el archivo apropiado al llamar a setTypeface. Esto simplifica la tipografía — basta con establecer fontFamily en el tema, y Android elegirá el archivo correcto automáticamente.

Uso de Typeface.create

El método Typeface.create(Typeface family, int style) crea una instancia de fuente con la familia y el estilo especificados. Si la familia ya tiene el estilo solicitado, se devuelve la instancia existente. Si el estilo no existe, Android lo sintetiza — aplicando pseudo-negrita o cursiva artificial a la fuente 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

La pseudo-negrita sintetizada puede verse de baja calidad en fuentes delgadas. Para obtener el mejor resultado, use un archivo de fuente con un estilo bold real. Typeface.create() con un estilo inexistente no lanza una excepción, sino que devuelve la variante disponible más cercana.

Typeface desde Archivo y Assets

Para cargar Typeface desde assets, use Typeface.createFromAsset(assetManager, path). La fuente se coloca en el directorio src/main/assets/fonts/, y la ruta se especifica relativa a assets. Este método funciona en todas las versiones de Android, pero no admite familias de fuentes y requiere especificar un archivo concreto para cada estilo.

El método Typeface.createFromFile(File) carga una fuente desde un archivo arbitrario en el sistema de archivos. Esto es útil para fuentes descargadas de la red o copiadas al almacenamiento interno de la aplicación. createFromFile tampoco requiere contexto, lo que es conveniente para tareas en segundo plano, pero el archivo debe ser legible.

Carga desde Assets con Caché

Cargar Typeface repetidamente desde assets mediante createFromAsset puede provocar la creación de objetos duplicados. Cada llamada a createFromAsset vuelve a cargar el archivo. Se recomienda implementar un caché de Typeface usando un HashMap, donde la clave sea la ruta del archivo y el valor sea la instancia cargada. Esto es especialmente relevante para listas con diferentes tipos de fuente.

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 caché en memoria garantiza que una fuente se cargue solo una vez por sesión de la aplicación. En cambios de configuración (rotación de pantalla), el caché persiste porque reside en un objeto companion. Para limpiar el caché cuando falta memoria, use WeakHashMap o escuche onTrimMemory.

Aplicar Typeface a TextView

Typeface se aplica a TextView mediante el método setTypeface(Typeface tf) o setTypeface(Typeface tf, int style). El segundo variante permite cambiar el estilo (bold/italic) respecto a la fuente actual. En XML se usa el atributo android:fontFamily con una referencia a la fuente o familia del sistema. Para configurar mediante programación, llamar a setTypeface(monospaceTypeface) reemplaza la fuente por la especificada.

Typeface afecta a todo el texto del TextView. Si se necesitan diferentes fuentes en una sola línea, use SpannableString con TypefaceSpan. TypefaceSpan acepta Typeface o familia y se aplica a un rango de caracteres. Esta es la única forma de mezclar fuentes dentro de un mismo TextView sin componentes anidados.

TypefaceSpan para Texto Parcial

Aplique TypefaceSpan solo a una parte de la cadena. Por ejemplo, el valor de una variable en el texto debe ser monoespaciado mientras el resto del texto permanece con la fuente del sistema. Cree un SpannableString y establezca un TypefaceSpan con Typeface MONOSPACE en el rango deseado. El resto del texto conserva la fuente original del 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

El texto “variableName” se mostrará en fuente monoespaciada azul, mientras que la palabra “Código:” permanece con la fuente del sistema. TypefaceSpan se puede combinar con cualquier otro span para un control preciso sobre cada segmento de texto.

Fuentes Personalizadas mediante Typeface

Android admite varios formatos de fuente: TrueType (TTF), OpenType (OTF) y Web Open Font Format (WOFF2) a partir de Android 10. TTF y OTF son los formatos principales para fuentes personalizadas. Las fuentes XML (Font Family) no son un formato separado, sino que sirven como descripción de qué archivo usar para cada estilo.

Para usar una fuente personalizada mediante res/font, cree un archivo XML de familia que especifique las rutas a los archivos de fuente para regular, bold e italic. Luego, en el tema de la aplicación, especifique android:fontFamily="@font/custom_family". Todas las instancias de TextView que usen este tema obtendrán automáticamente el estilo correcto para cada variante.

Carga de Fuentes Descargadas

Si una fuente se descarga de la red, guárdela en filesDir o cacheDir y cárguela mediante Typeface.createFromFile. Después de cargar, actualice el Typeface en TextView. Para carga asíncrona, use coroutine o DownloadManager, y después de completar, publique en el hilo de UI mediante Handler. Este es un escenario típico para aplicaciones con tipografía personalizada cargada bajo demanda.

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

Antes de cargar, verifique la disponibilidad del archivo: si el archivo está dañado o es inválido, Typeface.createFromFile lanza una RuntimeException. Se recomienda envolver la llamada en try-catch y, en caso de error, usar la fuente del sistema predeterminada.

Typeface en Jetpack Compose

En Jetpack Compose, el Typeface del SDK de Android no se usa directamente. En su lugar, Compose proporciona FontFamily y FontWeight para la tipografía. FontFamily se carga mediante Font.Resource y Font.File. El sistema tipográfico de Compose se define mediante MaterialTheme.typography, donde a cada estilo (h1, body1, button) se le puede asignar una FontFamily personalizada.

Para cargar una fuente desde recursos, Compose usa Font(R.font.font_name, weight, style). Una fuente desde assets se carga mediante Font(assetPath = "fonts/custom.otf", weight, style). Después de definir la fuente, se pasa a Typography y luego se aplica mediante MaterialTheme.typography.bodyLarge y estilos similares.

Conversión de Typeface a Fuente de Compose

Si tiene un Typeface existente creado mediante el SDK de Android, se puede usar en Compose mediante TypefaceAdapter o creando una FontFamily basada en Typeface. Obtenga el Typeface de Typeface.create y páselo a FontFamily.Custom(listOf(Font(typeface))). Sin embargo, se recomienda el enfoque nativo con Font.Resource, ya que está mejor optimizado para Compose.

Rendimiento y Caché

Cargar fuentes desde archivos es una operación potencialmente costosa. Cada llamada a Typeface.createFromAsset o Typeface.createFromFile lee el archivo del disco, lo analiza y crea un objeto Typeface. Para fuentes de 1-2 MB, esto toma de 10 a 50 ms en inicio en frío. El almacenamiento en caché de Typeface es una práctica obligatoria para aplicaciones con fuentes personalizadas.

El SDK de Android no almacena en caché las fuentes creadas mediante createFromAsset o createFromFile. A diferencia de las fuentes del sistema, que se precargan en el proceso Zygote, las fuentes personalizadas se cargan en cada acceso. Se recomienda usar LruCache o ConcurrentHashMap con un identificador de fuente como clave. Un tamaño de caché de 10-20 instancias cubre el conjunto de fuentes típico de una aplicación.

Optimización mediante Font Family (API 26+)

Android 8.0+ optimiza la carga de fuentes mediante XML Font Family. Al especificar android:fontFamily="@font/my_family" en el diseño XML, Android carga la fuente de manera diferida — solo cuando el componente se vuelve visible. El sistema también almacena en caché las fuentes cargadas mediante ResourcesCompat.getFont() en un caché global de procesos. Esto hace que el enfoque de recursos sea el más eficiente.

Typeface en RecyclerView

Al usar Typeface en adaptadores de RecyclerView, es importante no cargar la fuente en el método onBindViewHolder. Realice la carga una vez al crear el adaptador o use un ViewHolder con Typeface precargado. Si cada elemento de la lista requiere una fuente única, implemente un caché con WeakHashMap y límpielo al desplazarse más allá de las posiciones visibles para ahorrar memoria.