Esta página descreve como definir fontes no app Compose.
Definir fonte
Text
tem um parâmetro fontFamily
para permitir a configuração da fonte usada no
elemento combinável. Por padrão, as famílias de fontes Serif, Sans Serif, fontes monoespaçadas e cursivas
estão incluídas:
@Composable fun DifferentFonts() { Column { Text("Hello World", fontFamily = FontFamily.Serif) Text("Hello World", fontFamily = FontFamily.SansSerif) } }
Você pode usar o atributo fontFamily
para trabalhar com fontes personalizadas
definidas na pasta res/font
:
O exemplo a seguir mostra como definir uma fontFamily
com base nesses arquivos de
fonte e usando a função Font
:
val firaSansFamily = FontFamily( Font(R.font.firasans_light, FontWeight.Light), Font(R.font.firasans_regular, FontWeight.Normal), Font(R.font.firasans_italic, FontWeight.Normal, FontStyle.Italic), Font(R.font.firasans_medium, FontWeight.Medium), Font(R.font.firasans_bold, FontWeight.Bold) )
Você pode transmitir esse fontFamily
para o elemento combinável Text
. Como uma
fontFamily
pode incluir ponderações diferentes, é possível definir manualmente fontWeight
para
selecionar o peso certo para o texto:
Column { Text(text = "text", fontFamily = firaSansFamily, fontWeight = FontWeight.Light) Text(text = "text", fontFamily = firaSansFamily, fontWeight = FontWeight.Normal) Text( text = "text", fontFamily = firaSansFamily, fontWeight = FontWeight.Normal, fontStyle = FontStyle.Italic ) Text(text = "text", fontFamily = firaSansFamily, fontWeight = FontWeight.Medium) Text(text = "text", fontFamily = firaSansFamily, fontWeight = FontWeight.Bold) }
Para aprender a definir a tipografia em todo o app, consulte Sistemas de design personalizados no Compose.
Fontes para download
A partir do Compose 1.2.0, é possível usar a API de fontes para download no app Compose para fazer o download de fontes do Google de forma assíncrona e usá-las no app.
No momento, não há suporte para fontes para download fornecidas por fornecedores personalizados.
Usar fontes para download de maneira programática
Para fazer o download de uma fonte de forma programática no app, siga estas etapas:
- Adicione a dependência:
Groovy
dependencies { ... implementation "androidx.compose.ui:ui-text-google-fonts:1.6.8" }
Kotlin
dependencies { ... implementation("androidx.compose.ui:ui-text-google-fonts:1.6.8") }
- Inicialize o
GoogleFont.Provider
com as credenciais do Google Fonts:val provider = GoogleFont.Provider( providerAuthority = "com.google.android.gms.fonts", providerPackage = "com.google.android.gms", certificates = R.array.com_google_android_gms_fonts_certs )
Os parâmetros que o provedor recebe são:- A autoridade de provedor de fontes para a biblioteca Google Fonts.
- O pacote de provedor de fontes para confirmar a identidade do provedor.
- Uma lista de conjuntos de hashes para que os certificados confirmem a identidade
do provedor. Encontre os hashes necessários para o provedor do Google Fonts
no arquivo
font_certs.xml
(em inglês) do app de exemplo Jetchat.
- Defina um
FontFamily
:// ... import androidx.compose.ui.text.googlefonts.GoogleFont import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.googlefonts.Font // ... val fontName = GoogleFont("Lobster Two") val fontFamily = FontFamily( Font(googleFont = fontName, fontProvider = provider) )
É possível consultar outros parâmetros para sua fonte, como peso e estilo, comFontWeight
eFontStyle
, respectivamente:// ... import androidx.compose.ui.text.googlefonts.GoogleFont import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.googlefonts.Font // ... val fontName = GoogleFont("Lobster Two") val fontFamily = FontFamily( Font( googleFont = fontName, fontProvider = provider, weight = FontWeight.Bold, style = FontStyle.Italic ) )
- Configure o
FontFamily
para ser usado na função combinável de texto:
Text( fontFamily = fontFamily, text = "Hello World!" )
Você também pode definir a
tipografia para usar
seu FontFamily
:
val MyTypography = Typography( labelMedium = TextStyle( fontFamily = fontFamily, fontWeight = FontWeight.Normal, fontSize = 12.sp/*...*/ ), labelLarge = TextStyle( fontFamily = fontFamily, fontWeight = FontWeight.Bold, letterSpacing = 2.sp, /*...*/ ), displayMedium = TextStyle( fontFamily = fontFamily, fontWeight = FontWeight.SemiBold/*...*/ ), /*...*/ )
Em seguida, defina a tipografia para o tema do seu app:
MyAppTheme( typography = MyTypography )/*...*/
Para conferir um exemplo de app que implementa fontes para download no Compose com o Material3, consulte o app de exemplo Jetchat.
Adicionar fontes substitutas
Você pode determinar uma cadeia de substitutos para sua fonte caso o download da fonte não seja feito corretamente. Por exemplo, se você tiver a fonte para download definida desta forma:
// ... import androidx.compose.ui.text.googlefonts.Font // ... val fontName = GoogleFont("Lobster Two") val fontFamily = FontFamily( Font(googleFont = fontName, fontProvider = provider), Font(googleFont = fontName, fontProvider = provider, weight = FontWeight.Bold) )
Você pode definir os padrões da fonte para os dois pesos:
// ... import androidx.compose.ui.text.font.Font import androidx.compose.ui.text.googlefonts.Font // ... val fontName = GoogleFont("Lobster Two") val fontFamily = FontFamily( Font(googleFont = fontName, fontProvider = provider), Font(resId = R.font.my_font_regular), Font(googleFont = fontName, fontProvider = provider, weight = FontWeight.Bold), Font(resId = R.font.my_font_regular_bold, weight = FontWeight.Bold) )
Verifique se você está adicionando as importações corretas.
Essa definição cria uma FontFamily
contendo duas cadeias,
uma para cada peso. O mecanismo de carregamento tentará resolver a fonte on-line primeiro
e, em seguida, a fonte localizada na pasta de recursos R.font
local.
Depurar sua implementação
Para verificar se o download da fonte está sendo feito corretamente, defina um gerenciador de corrotina de depuração. Ele fornece o comportamento do que fazer caso a fonte não carregue de forma assíncrona.
Comece criando um
CoroutineExceptionHandler
:
val handler = CoroutineExceptionHandler { _, throwable -> // process the Throwable Log.e(TAG, "There has been an issue: ", throwable) }
Transmita-o ao método
createFontFamilyResolver
para que o resolvedor use o novo gerenciador:
CompositionLocalProvider( LocalFontFamilyResolver provides createFontFamilyResolver(LocalContext.current, handler) ) { Column { Text( text = "Hello World!", style = MaterialTheme.typography.bodyMedium ) } }
Você também pode usar a API
isAvailableOnDevice
do provedor para testar se ele está disponível e se os certificados estão
configurados corretamente. Para fazer isso, chame o método isAvailableOnDevice
,
que vai retornar "false" se o provedor estiver configurado incorretamente.
val context = LocalContext.current LaunchedEffect(Unit) { if (provider.isAvailableOnDevice(context)) { Log.d(TAG, "Success!") } }
Avisos
A biblioteca Google Fonts leva vários meses para disponibilizar novas fontes no Android.
Há um intervalo de tempo entre a adição de uma fonte em
fonts.google.com e a disponibilização dela pela
API de fontes para download (no sistema de visualização ou no Compose). As fontes
recém-adicionadas podem não ser carregadas no seu app com uma
IllegalStateException
.
Para ajudar os desenvolvedores a identificar esse erro em relação a outros tipos de erro de carregamento de fonte,
adicionamos mensagens descritivas para a exceção no Compose com as mudanças
aqui.
Se você encontrar algum problema, informe-o usando o Issue
Tracker.
Usar fontes variáveis
Uma fonte variável é um formato que permite que um arquivo de fonte contenha estilos diferentes. Com fontes variáveis, você pode modificar os eixos (ou parâmetros) para gerar seu estilo preferido. Esses eixos podem ser padrão, como peso, largura, inclinação e itálico, ou personalizados, que diferem entre as fontes variáveis.
O uso de fontes variáveis em vez de arquivos de fontes normais permite que você tenha apenas um arquivo de fonte, em vez de vários.
Para saber mais sobre fontes variáveis, consulte a página de conhecimento sobre o Google Fonts, o catálogo completo de fontes variáveis disponíveis e uma tabela dos eixos compatíveis com cada fonte.
Este documento mostra como implementar uma fonte variável no app Compose.
Carregar uma fonte variável
Faça o download da fonte variável que você quer usar (por exemplo, Roboto Flex) e coloque-a na pasta
app/res/font
do app. Verifique se o arquivo .ttf
adicionado é a versão da fonte variável da fonte, e o nome do arquivo precisa estar em letras minúsculas e não ter caracteres especiais.Para carregar uma fonte variável, defina um
FontFamily
usando a fonte colocada no diretóriores/font/
:// In Typography.kt @OptIn(ExperimentalTextApi::class) val displayLargeFontFamily = FontFamily( Font( R.font.robotoflex_variable, variationSettings = FontVariation.Settings( FontVariation.weight(950), FontVariation.width(30f), FontVariation.slant(-6f), ) ) )
A API
FontVariation
permite configurar eixos de fonte padrão, como peso, largura e inclinação. Esses são eixos padrão disponíveis para qualquer fonte variável. Você pode criar diferentes configurações da fonte com base no local em que ela será usada.As fontes variáveis estão disponíveis apenas para as versões O e mais recentes do Android. Portanto, adicione uma proteção e configure um substituto apropriado:
// In Typography.kt val default = FontFamily( /* * This can be any font that makes sense */ Font( R.font.robotoflex_static_regular ) ) @OptIn(ExperimentalTextApi::class) val displayLargeFontFamily = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { FontFamily( Font( R.font.robotoflex_variable, variationSettings = FontVariation.Settings( FontVariation.weight(950), FontVariation.width(30f), FontVariation.slant(-6f), ) ) ) } else { default }
Extraia as configurações em um conjunto de constantes para facilitar a reutilização e substitua as configurações de fonte por estas constantes:
// VariableFontDimension.kt object DisplayLargeVFConfig { const val WEIGHT = 950 const val WIDTH = 30f const val SLANT = -6f const val ASCENDER_HEIGHT = 800f const val COUNTER_WIDTH = 500 } @OptIn(ExperimentalTextApi::class) val displayLargeFontFamily = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { FontFamily( Font( R.font.robotoflex_variable, variationSettings = FontVariation.Settings( FontVariation.weight(DisplayLargeVFConfig.WEIGHT), FontVariation.width(DisplayLargeVFConfig.WIDTH), FontVariation.slant(DisplayLargeVFConfig.SLANT), ) ) ) } else { default }
Configure a tipografia do Material Design 3 para usar o
FontFamily
:// Type.kt val Typography = Typography( displayLarge = TextStyle( fontFamily = displayLargeFontFamily, fontSize = 50.sp, lineHeight = 64.sp, letterSpacing = 0.sp, /***/ ) )
Este exemplo usa a tipografia do Material 3 (link em inglês)
displayLarge
, que tem configurações de fonte padrão e usos recomendados diferentes. Por exemplo, usedisplayLarge
para texto curto e crítico, já que é o maior texto na tela.Com o Material 3, você pode mudar os valores padrão de
TextStyle
efontFamily
para personalizar a tipografia. No snippet acima, você configura instâncias deTextStyle
para personalizar as configurações de fonte de cada família.Agora que você definiu a tipografia, transmita-a para a
MaterialTheme
do M3:MaterialTheme( colorScheme = MaterialTheme.colorScheme, typography = Typography, content = content )
Por fim, use um elemento combinável
Text
e especifique o estilo como um dos estilos de tipografia definidos,MaterialTheme.typography.displayLarge
:@Composable @Preview fun CardDetails() { MyCustomTheme { Card( shape = RoundedCornerShape(8.dp), elevation = CardDefaults.cardElevation(defaultElevation = 4.dp), modifier = Modifier .fillMaxWidth() .padding(16.dp) ) { Column( modifier = Modifier.padding(16.dp) ) { Text( text = "Compose", style = MaterialTheme.typography.displayLarge, modifier = Modifier.padding(bottom = 8.dp), maxLines = 1 ) Text( text = "Beautiful UIs on Android", style = MaterialTheme.typography.headlineMedium, modifier = Modifier.padding(bottom = 8.dp), maxLines = 2 ) Text( text = "Jetpack Compose is Android’s recommended modern toolkit for building native UI. It simplifies and accelerates UI development on Android. Quickly bring your app to life with less code, powerful tools, and intuitive Kotlin APIs.", style = MaterialTheme.typography.bodyLarge, modifier = Modifier.padding(bottom = 8.dp), maxLines = 3 ) } } } }
Cada
Text
combinável é configurado com o estilo do tema do Material Design e contém uma configuração de fonte variável diferente. É possível usarMaterialTheme.typography
para extrair a tipografia fornecida ao elemento combinávelMaterialTheme
do M3.
Usar eixos personalizados
As fontes também podem ter eixos personalizados. Eles são definidos no próprio arquivo de fontes.
Por exemplo, a fonte Roboto Flex tem o eixo de altura do ascendente ("YTAS"
), que
ajusta a altura dos ascendentes minúsculos, enquanto a largura do contador ("XTRA"
)
ajusta a largura de cada letra.
É possível alterar o valor desses eixos nas configurações FontVariation
.
Para saber mais sobre os eixos personalizados que podem ser configurados para uma fonte, consulte a tabela de eixos compatíveis com cada fonte.
Para usar eixos personalizados, defina funções para os eixos personalizados
ascenderHeight
ecounterWidth
:fun ascenderHeight(ascenderHeight: Float): FontVariation.Setting { require(ascenderHeight in 649f..854f) { "'Ascender Height' must be in 649f..854f" } return FontVariation.Setting("YTAS", ascenderHeight) } fun counterWidth(counterWidth: Int): FontVariation.Setting { require(counterWidth in 323..603) { "'Counter width' must be in 323..603" } return FontVariation.Setting("XTRA", counterWidth.toFloat()) }
Essas funções fazem o seguinte:
- Defina proteções para os valores que eles podem aceitar. Como você pode notar no
catálogo de fontes variáveis,
ascenderHeight (YTAS)
tem um valor mínimo de649f
e máximo de854f
. - Retorne a configuração da fonte para que a configuração esteja pronta para ser adicionada à fonte. No
método
FontVariation.Setting()
, o nome do eixo (YTAS, XTRA
) é fixado no código e usa o valor como um parâmetro.
- Defina proteções para os valores que eles podem aceitar. Como você pode notar no
catálogo de fontes variáveis,
Usando os eixos com a configuração da fonte, transmita outros parâmetros para cada
Font
carregado:@OptIn(ExperimentalTextApi::class) val displayLargeFontFamily = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { FontFamily( Font( R.font.robotoflex_variable, variationSettings = FontVariation.Settings( FontVariation.weight(DisplayLargeVFConfig.WEIGHT), FontVariation.width(DisplayLargeVFConfig.WIDTH), FontVariation.slant(DisplayLargeVFConfig.SLANT), ascenderHeight(DisplayLargeVFConfig.ASCENDER_HEIGHT), counterWidth(DisplayLargeVFConfig.COUNTER_WIDTH) ) ) ) } else { default }
Observe que a altura dos ascendentes minúsculos agora é aumentada e o outro texto é mais amplo:
Outros recursos
Para mais informações, consulte a seguinte postagem do blog sobre fontes variáveis:
Recomendados para você
- Observação: o texto do link aparece quando o JavaScript está desativado.
- Recursos no Compose
- Estilizar texto
- Material Design 2 no Compose