dp — conceptos básicos, píxeles independientes de densidad en Android

¿Qué es dp en Android?

dp (density-independent pixel) es una unidad de medida virtual en Android, introducida para unificar los tamaños de los elementos de la UI en dispositivos con diferentes densidades de píxeles. Un dp equivale aproximadamente a un píxel físico en una pantalla con densidad de 160 dpi (mdpi). En una pantalla con densidad de 320 dpi (xhdpi), 1 dp equivale a 2 píxeles físicos. Por lo tanto, el tamaño físico de un elemento en la pantalla sigue siendo el mismo — aproximadamente 1/160 de pulgada. Según Android Developers (2025), dp es la única unidad de medida que se debe usar para dimensiones de layout, padding, margin y ancho/alto de view.

Por qué no se debe usar px

Si se asigna a un botón un ancho de 160 px, en una pantalla mdpi medirá 1 pulgada de ancho, pero en una pantalla xxxhdpi (640 dpi) — solo 0.25 pulgadas. dp resuelve este problema: 160 dp en cualquier pantalla equivaldrán a 1 pulgada. Android convierte automáticamente dp a px mediante DisplayMetrics.density durante el renderizado. Según Android Developer Blog (2025), antes de la introducción de dp (Android 1.0), los desarrolladores calculaban manualmente los offsets en px, lo que provocaba errores constantes al portar.

dp, px y sp: cuál es la diferencia

dp, px y sp son tres unidades de medida en Android, cada una con su propósito. px es un píxel físico de pantalla que depende de la densidad. dp es un píxel independiente de densidad para dimensiones de elementos. sp es un píxel independiente de escala para texto que además tiene en cuenta la configuración del tamaño de fuente del sistema. Según Material Design (2025), la diferencia entre dp y sp es un punto clave de accesibilidad: los usuarios con mala vista aumentan el tamaño de la fuente, y los valores sp se ajustan automáticamente, mientras que dp no.

Fórmula para convertir dp a px y viceversa

La fórmula de conversión de dp a px: px = dp × (dpi / 160). Para la conversión inversa: dp = px / (dpi / 160). density es la relación dpi / 160, que Android calcula basándose en DisplayMetrics. En mdpi density = 1.0, en hdpi = 1.5, en xhdpi = 2.0, en xxhdpi = 3.0, en xxxhdpi = 4.0. Así, 48 dp en píxeles: en mdpi — 48 px, en xxhdpi — 144 px. Según Google I/O 2024, esta fórmula se puede usar para la conversión aproximada de pt (points) de iOS a dp — 1 pt ≈ 1 dp.

dimens.xml: gestión centralizada de dimensiones

dimens.xml es un archivo de recursos de Android en res/values/, destinado a almacenar todas las dimensiones en dp (y sp para texto). Centralizar las dimensiones en dimens.xml simplifica el mantenimiento: cambiar un valor en dimens.xml actualiza el tamaño en todas las pantallas de la aplicación. Se pueden crear archivos dimens.xml cualificados para diferentes densidades (values-hdpi, values-xhdpi). Según Android Jetpack Docs (2025), Google recomienda almacenar en dimens.xml márgenes, padding, anchos de elementos (constantes), tamaños de avatares y altura de toolbar.

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

En este archivo, cada dimen tiene un nombre y un valor. Uso en marcado XML: @dimen/avatar_size. Según Material Design Guidelines (2025), el paso básico de cuadrícula en Android es 8 dp (8-point grid). Todos los márgenes, tamaños de elementos y distancias deben ser múltiplos de 8 dp: 8, 16, 24, 32, 48, 56, 64, 72 dp. Para texto, el paso es 4 sp.

Uso programático de dp en Kotlin y XML

En el marcado XML, dp se usa directamente: android:layout_width="48dp". En código programático (Kotlin/Java), es necesario convertir dp a px mediante TypedResource o funciones de extensión. TypedResource proporciona métodos listos para trabajar con dp en tiempo de ejecución: getDimensionPixelSize() devuelve un valor entero en px. En Jetpack Compose, dp es la unidad de medida estándar en modificadores y contenedores de layout.

// Conversión de dp a px programáticamente
fun Context.dpToPx(dp: Int): Int {
    return (dp * resources
        .displayMetrics
        .density).toInt()
}

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

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

En este ejemplo, dpToPx() es una función de extensión para Context, que convierte dp a px usando displayMetrics.density. En Jetpack Compose, dp está integrado en el sistema de tipos y no requiere conversión manual — el compilador traduce automáticamente dp a px en la etapa de renderizado.

Marcado XML con 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"
/>

En XML, dp se especifica como sufijo del número — margin_top="16dp". Para texto se usa sp — textSize="@dimen/text_size_body". La referencia @dimen permite la gestión centralizada de valores. Usar match_parent para el ancho y 48dp para la altura es un patrón estándar de Material Design para botones.

Errores comunes al usar dp

Según un análisis de aplicaciones Android de Google Play Console (2025), los cinco errores más comunes son: usar px en lugar de dp en el marcado XML, falta de dimens.xml (valores escritos inline), conversión incorrecta de dp a px en código (usando división de enteros), ignorar sp para texto y no tener en cuenta la configuración del tamaño de fuente del sistema mediante sp. La división de enteros es el error más peligroso: en Kotlin val px = dp * density — si dp y density son Int, el resultado también será Int, y se pierde precisión.

• px en lugar de dp — la aplicación se ve diferente en dispositivos con distintas densidades. Se corrige reemplazando px por dp en XML.
• Valores inline — las dimensiones se escriben directamente en los archivos de layout. Duplicar valores complica el mantenimiento y las actualizaciones.
• sp para texto — usar dp para el tamaño de fuente ignora la configuración del usuario, rompiendo la accesibilidad.
• División de enteros — en Kotlin, dividir Int entre Int da Int, perdiendo la parte fraccionaria. Use siempre Float.