Typeface — o que é, tipos de fonte e trabalho no Android

O que é Typeface?

Typeface — é uma classe Android que encapsula informações da fonte: sua família (Roboto, Arial, Serif) e modificadores de estilo (bold, italic). Ao contrário do UIFont no iOS, Typeface não contém informação de tamanho — o tamanho do texto é definido separadamente pela propriedade textSize no TextView ou TextStyle no Spannable. Typeface é responsável apenas pelo tipo e família da fonte.

A classe está disponível em todos os níveis de API. Antes do Android 4.4, Typeface só suportava um conjunto limitado de fontes do sistema: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. A partir do Android 8.0 (API 26), foi adicionado suporte para carregamento de fontes personalizadas via recursos XML, e o Android 10 adicionou suporte para fontes variáveis.

Constantes Typeface Integradas

O Android fornece várias instâncias Typeface integradas: Typeface.DEFAULT — fonte do sistema Roboto (Material) ou Noto (AOSP), DEFAULT_BOLD — versão em negrito, MONOSPACE — fonte monoespaçada para código, SERIF — fonte com serifa (Noto Serif), SANS_SERIF — sem serifa (Noto Sans). Essas constantes estão disponíveis sem contexto e não requerem permissões de leitura de arquivos.

Typeface no Sistema

O sistema Android usa Typeface para renderizar todo o texto, incluindo interface do sistema, títulos, legendas e notificações. Cada aplicativo pode substituir a fonte padrão via tema (android:fontFamily) ou programaticamente via setTypeface(). Typeface se aplica a todos os componentes herdados de TextView: botões, EditText e visualizações personalizadas.

Criar Typeface a partir de Recursos

Android 8.0+ permite adicionar fontes a res/font e usá-las via recursos XML. O arquivo de fonte (TTF ou OTF) é colocado em res/font, após o que é criada uma referência R.font.font_name. Typeface é carregado via ResourcesCompat.getFont(context, R.font.font_name). Este método é preferível porque a fonte é compilada no APK e suporta sistemas de build ProGuard.

A abordagem de recursos também suporta famílias de fontes via um arquivo XML em res/font: você pode especificar vários arquivos para diferentes tipos (regular, bold, italic) e o sistema selecionará automaticamente o arquivo apropriado ao chamar setTypeface. Isso simplifica a tipografia — basta definir fontFamily no tema, e o Android escolherá o arquivo correto automaticamente.

Usando Typeface.create

O método Typeface.create(Typeface family, int style) cria uma instância de fonte com a família e estilo especificados. Se a família já tiver o estilo solicitado, a instância existente é retornada. Se o estilo não existir, o Android o sintetiza — aplicando pseudo-negrito ou itálico artificial à fonte 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

O pseudo-negrito sintetizado pode parecer de baixa qualidade em fontes finas. Para melhores resultados, use um arquivo de fonte com um tipo bold real. Typeface.create() com um estilo inexistente não lança exceção, mas retorna a variante disponível mais próxima.

Typeface de Arquivo e Assets

Para carregar Typeface de assets, use Typeface.createFromAsset(assetManager, path). A fonte é colocada no diretório src/main/assets/fonts/, e o caminho é especificado relativo a assets. Este método funciona em todas as versões do Android, mas não suporta famílias de fontes e requer especificar um arquivo específico para cada tipo.

O método Typeface.createFromFile(File) carrega uma fonte de um arquivo qualquer no sistema de arquivos. Isso é útil para fontes baixadas da rede ou copiadas para o armazenamento interno do aplicativo. createFromFile também não requer contexto, o que é conveniente para tarefas em segundo plano, mas o arquivo deve ser legível.

Carregamento de Assets com Cache

Carregar Typeface repetidamente de assets via createFromAsset pode levar à criação de objetos duplicados. Cada chamada createFromAsset recarrega o arquivo. Recomenda-se implementar um cache Typeface usando um HashMap, onde a chave é o caminho do arquivo e o valor é a instância carregada. Isso é especialmente relevante para listas com diferentes tipos de fonte.

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

Um cache em memória garante que uma fonte seja carregada apenas uma vez por sessão do aplicativo. Em mudanças de configuração (rotação de tela), o cache persiste porque reside em um objeto companion. Para limpar o cache em caso de pouca memória, use WeakHashMap ou escute onTrimMemory.

Aplicar Typeface a TextView

Typeface é aplicado a TextView via o método setTypeface(Typeface tf) ou setTypeface(Typeface tf, int style). A segunda variante permite alterar o estilo (bold/italic) em relação à fonte atual. Em XML, o atributo android:fontFamily é usado com uma referência à fonte ou família do sistema. Para configuração programática, chamar setTypeface(monospaceTypeface) substitui a fonte pela especificada.

Typeface afeta todo o texto do TextView. Se forem necessárias fontes diferentes em uma única linha, use SpannableString com TypefaceSpan. TypefaceSpan aceita Typeface ou família e é aplicado a um intervalo de caracteres. Esta é a única maneira de misturar fontes dentro de um único TextView sem componentes aninhados.

TypefaceSpan para Texto Parcial

Aplique TypefaceSpan apenas a parte da string. Por exemplo, um valor de variável no texto deve ser monoespaçado enquanto o restante do texto permanece com a fonte do sistema. Crie um SpannableString e defina um TypefaceSpan com Typeface MONOSPACE no intervalo desejado. O restante do texto mantém a fonte original do 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

O texto “variableName” aparecerá em fonte monoespaçada azul, enquanto a palavra “Código:” permanece na fonte do sistema. TypefaceSpan pode ser combinado com qualquer outro span para controle preciso sobre cada segmento de texto.

Fontes Personalizadas via Typeface

O Android suporta vários formatos de fonte: TrueType (TTF), OpenType (OTF) e Web Open Font Format (WOFF2) a partir do Android 10. TTF e OTF são os principais formatos para fontes personalizadas. As fontes XML (Font Family) não são um formato separado, mas servem como descrição de qual arquivo usar para cada tipo.

Para usar uma fonte personalizada via res/font, crie um arquivo XML de família especificando os caminhos para os arquivos de fonte para regular, bold e italic. Em seguida, no tema do aplicativo, especifique android:fontFamily="@font/custom_family". Todas as instâncias de TextView que usam este tema obterão automaticamente o tipo correto para cada estilo.

Carregando Fontes Baixadas

Se uma fonte for baixada da rede, salve-a em filesDir ou cacheDir e carregue-a via Typeface.createFromFile. Após o carregamento, atualize o Typeface no TextView. Para carregamento assíncrono, use coroutine ou DownloadManager e, após a conclusão, publique na thread de UI via Handler. Este é um cenário típico para aplicativos com tipografia personalizada carregada sob 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 carregar, verifique a disponibilidade do arquivo: se o arquivo estiver corrompido ou inválido, Typeface.createFromFile lança uma RuntimeException. Recomenda-se envolver a chamada em try-catch e, em caso de erro, usar a fonte do sistema padrão.

Typeface no Jetpack Compose

No Jetpack Compose, o Typeface do SDK Android não é usado diretamente. Em vez disso, o Compose fornece FontFamily e FontWeight para tipografia. FontFamily é carregado via Font.Resource e Font.File. O sistema de tipografia do Compose é definido via MaterialTheme.typography, onde cada estilo (h1, body1, button) pode receber uma FontFamily personalizada.

Para carregar uma fonte de recursos, o Compose usa Font(R.font.font_name, weight, style). Uma fonte de assets é carregada via Font(assetPath = "fonts/custom.otf", weight, style). Após definir a fonte, ela é passada para Typography e então aplicada via MaterialTheme.typography.bodyLarge e estilos semelhantes.

Convertendo Typeface para Fonte do Compose

Se você tiver um Typeface existente criado via SDK Android, ele pode ser usado no Compose via TypefaceAdapter ou criando uma FontFamily baseada no Typeface. Obtenha o Typeface de Typeface.create e passe-o para FontFamily.Custom(listOf(Font(typeface))). No entanto, a abordagem nativa com Font.Resource é recomendada, pois é melhor otimizada para o Compose.

Desempenho e Cache

Carregar fontes de arquivos é uma operação potencialmente cara. Cada chamada a Typeface.createFromAsset ou Typeface.createFromFile lê o arquivo do disco, analisa-o e cria um objeto Typeface. Para fontes de 1-2 MB, isso leva de 10 a 50 ms na inicialização a frio. O armazenamento em cache de Typeface é uma prática obrigatória para aplicativos com fontes personalizadas.

O SDK Android não armazena em cache fontes criadas via createFromAsset ou createFromFile. Ao contrário das fontes do sistema, que são pré-carregadas no processo Zygote, as fontes personalizadas são carregadas a cada acesso. Recomenda-se usar LruCache ou ConcurrentHashMap com um identificador de fonte como chave. Um tamanho de cache de 10-20 instâncias cobre o conjunto típico de fontes de um aplicativo.

Otimização via Font Family (API 26+)

Android 8.0+ otimiza o carregamento de fontes através de XML Font Family. Ao especificar android:fontFamily="@font/my_family" no layout XML, o Android carrega a fonte preguiçosamente — apenas quando o componente se torna visível. O sistema também armazena em cache as fontes carregadas via ResourcesCompat.getFont() em um cache global de processos. Isso torna a abordagem de recursos a mais eficiente.

Typeface no RecyclerView

Ao usar Typeface em adaptadores RecyclerView, é importante não carregar a fonte no método onBindViewHolder. Realize o carregamento uma vez ao criar o adaptador ou use um ViewHolder com Typeface pré-carregado. Se cada item da lista exigir uma fonte única, implemente um cache usando WeakHashMap e limpe-o ao rolar além das posições visíveis para economizar memória.