dp — fundamentos, pixels independentes de densidade no Android

O que é dp no Android?

dp (density-independent pixel) é uma unidade de medida virtual no Android, introduzida para unificar os tamanhos dos elementos de UI em dispositivos com diferentes densidades de pixels. Um dp é aproximadamente igual a um pixel físico em uma tela com densidade de 160 dpi (mdpi). Em uma tela com densidade de 320 dpi (xhdpi), 1 dp equivale a 2 pixels físicos. Assim, o tamanho físico de um elemento na tela permanece o mesmo — cerca de 1/160 de polegada. De acordo com o Android Developers (2025), dp é a única unidade de medida que deve ser usada para dimensões de layout, padding, margin e largura/altura de view.

Por que não usar px

Se você definir a largura de um botão como 160 px, em uma tela mdpi ele terá 1 polegada de largura, mas em uma tela xxxhdpi (640 dpi) — apenas 0,25 polegadas. dp resolve este problema: 160 dp em qualquer tela equivalerá a 1 polegada. O Android converte automaticamente dp para px via DisplayMetrics.density durante a renderização. De acordo com o Android Developer Blog (2025), antes da introdução do dp (Android 1.0), os desenvolvedores calculavam manualmente os offsets em px, o que causava bugs constantes ao portar.

dp, px e sp: qual a diferença

dp, px e sp são três unidades de medida no Android, cada uma com seu propósito. px é um pixel físico de tela que depende da densidade. dp é um pixel independente de densidade para dimensões de elementos. sp é um pixel independente de escala para texto que também leva em consideração as configurações de tamanho de fonte do sistema. De acordo com o Material Design (2025), a diferença entre dp e sp é um ponto chave de acessibilidade: usuários com visão fraca aumentam o tamanho da fonte, e os valores sp se ajustam automaticamente, enquanto dp não.

Fórmula para converter dp em px e vice-versa

A fórmula de conversão de dp para px: px = dp × (dpi / 160). Para conversão reversa: dp = px / (dpi / 160). density é a relação dpi / 160, que o Android calcula com base no DisplayMetrics. Em mdpi density = 1.0, em hdpi = 1.5, em xhdpi = 2.0, em xxhdpi = 3.0, em xxxhdpi = 4.0. Assim, 48 dp em pixels: em mdpi — 48 px, em xxhdpi — 144 px. De acordo com o Google I/O 2024, esta fórmula pode ser usada para conversão aproximada de pt (points) do iOS para dp — 1 pt ≈ 1 dp.

dimens.xml: gerenciamento centralizado de dimensões

dimens.xml é um arquivo de recursos do Android em res/values/, destinado a armazenar todas as dimensões em dp (e sp para texto). Centralizar as dimensões no dimens.xml simplifica a manutenção: alterar um valor no dimens.xml atualiza o tamanho em todas as telas do aplicativo. Você pode criar arquivos dimens.xml qualificados para diferentes densidades (values-hdpi, values-xhdpi). De acordo com o Android Jetpack Docs (2025), o Google recomenda armazenar margens, padding, larguras de elementos (constantes), tamanhos de avatar e altura da toolbar no dimens.xml.

<resources>
    <dimen name="margin_small">8dp</dimen>
    <dimen name="margin_medium">16dp</dimen>
    <dimen name="margin_large">24dp</dimen>
    <dimen name="avatar_size">48dp</dimen>
    <dimen name="toolbar_height">56dp</dimen>
    <dimen name="text_size_body">14sp</dimen>
    <dimen name="icon_size_small">24dp</dimen>
</resources>

Neste arquivo, cada dimen tem um nome e um valor. Uso em marcação XML: @dimen/avatar_size. De acordo com as Material Design Guidelines (2025), o passo básico de grade no Android é 8 dp (grade de 8 pontos). Todas as margens, tamanhos de elementos e distâncias devem ser múltiplos de 8 dp: 8, 16, 24, 32, 48, 56, 64, 72 dp. Para texto, o passo é 4 sp.

Uso programático de dp em Kotlin e XML

Na marcação XML, dp é usado diretamente: android:layout_width="48dp". Em código programático (Kotlin/Java), é necessário converter dp para px usando TypedResource ou funções de extensão. TypedResource fornece métodos prontos para trabalhar com dp em tempo de execução: getDimensionPixelSize() retorna um valor inteiro em px. No Jetpack Compose, dp é a unidade de medida padrão em modificadores e contêineres de layout.

// Conversão de dp para px programaticamente
fun Context.dpToPx(dp: Int): Int {
    return (dp * resources
        .displayMetrics
        .density).toInt()
}

// Uso em Activity
val paddingPx = dpToPx(16)
button.setPadding(
    paddingPx,
    paddingPx,
    paddingPx,
    paddingPx,
)

// Jetpack Compose: dp como unidade integrada
Modifier
    .padding(16.dp)
    .size(48.dp)

Neste exemplo, dpToPx() é uma função de extensão para Context, que converte dp para px usando displayMetrics.density. No Jetpack Compose, dp está embutido no sistema de tipos e não requer conversão manual — o compilador traduz automaticamente dp para px no estágio de renderização.

Marcação XML com dp

<Button
    android:layout_width="match_parent"
    android:layout_height="48dp"
    android:padding="@dimen/margin_medium"
    android:textSize="@dimen/text_size_body"
    android:text="@string/button_label"
    android:layout_marginTop="16dp"
/>

Em XML, dp é especificado como sufixo do número — margin_top="16dp". Para texto, usa-se sp — textSize="@dimen/text_size_body". A referência @dimen permite o gerenciamento centralizado de valores. Usar match_parent para largura e 48dp para altura é um padrão padrão do Material Design para botões.

Erros comuns ao usar dp

De acordo com uma análise de aplicativos Android do Google Play Console (2025), os cinco erros mais comuns são: usar px em vez de dp na marcação XML, falta de dimens.xml (valores escritos inline), conversão incorreta de dp para px em código (usando divisão de inteiros), ignorar sp para texto e não considerar as configurações de tamanho de fonte do sistema via sp. A divisão de inteiros é o erro mais perigoso: em Kotlin val px = dp * density — se dp e density forem Int, o resultado também será Int, e a precisão é perdida.

• px em vez de dp — o aplicativo parece diferente em dispositivos com densidades distintas. Corrige-se substituindo px por dp em XML.
• Valores inline — as dimensões são escritas diretamente nos arquivos de layout. Duplicar valores complica a manutenção e as atualizações.
• sp para texto — usar dp para tamanho de fonte ignora as configurações do usuário, quebrando a acessibilidade.
• Divisão de inteiros — em Kotlin, dividir Int por Int resulta em Int, perdendo a parte fracionária. Sempre use Float.