dp — basis, dichtheidsonafhankelijke pixels in Android

Wat is dp in Android?

dp (density-independent pixel) — is een virtuele meeteenheid in Android, geïntroduceerd om de afmetingen van UI-elementen op apparaten met verschillende pixeldichtheid te uniformeren. Eén dp is ongeveer gelijk aan één fysieke pixel op een scherm met een dichtheid van 160 dpi (mdpi). Op een scherm met een dichtheid van 320 dpi (xhdpi) is 1 dp gelijk aan 2 fysieke pixels. Zo blijft de fysieke grootte van het element op het scherm hetzelfde — ongeveer 1/160 inch. Volgens Android Developers (2025) is dp de enige meeteenheid die moet worden gebruikt voor layout, padding, margin en breedte/hoogte van views.

Waarom px niet kan worden gebruikt

Als u een knop een breedte van 160 px geeft, is deze op een mdpi-scherm 1 inch breed en op een xxxhdpi-scherm (640 dpi) — slechts 0.25 inch. dp lost dit probleem op: 160 dp is op elk scherm gelijk aan 1 inch. Android converteert automatisch dp naar px via DisplayMetrics.density bij het renderen. Volgens Android Developer Blog (2025) gebruikten ontwikkelaars vóór de introductie van dp (Android 1.0) handmatig px, wat leidde tot constante fouten bij het porteren.

dp, px en sp: wat is het verschil

dp, px en sp — drie meeteenheden in Android, elk met een eigen doel. px — de fysieke pixel van het scherm, afhankelijk van de dichtheid. dp — dichtheidsonafhankelijke pixel voor elementafmetingen. sp — scale-independent pixel voor tekst, die ook rekening houdt met systeeminstellingen voor lettergrootte. Volgens Material Design (2025) is het verschil tussen dp en sp een belangrijk toegankelijkheidsaspect: gebruikers met slecht zicht vergroten het lettertype en sp-waarden passen zich automatisch aan, terwijl dp — niet.

Formule voor conversie van dp naar px en terug

Conversieformule dp naar px: px = dp × (dpi / 160). Voor omgekeerde conversie: dp = px / (dpi / 160). density — de verhouding dpi / 160, die Android berekent op basis van DisplayMetrics. Op mdpi density = 1.0, op hdpi = 1.5, op xhdpi = 2.0, op xxhdpi = 3.0, op xxxhdpi = 4.0. Dus 48 dp in pixels: op mdpi — 48 px, op xxhdpi — 144 px. Volgens Google I/O 2024 kan deze formule worden gebruikt voor de geschatte conversie van iOS pt (points) naar dp — 1 pt ≈ 1 dp.

dimens.xml: gecentraliseerd beheer van afmetingen

dimens.xml — het Android resourcebestand in res/values/, bedoeld voor het opslaan van alle afmetingen in dp (en sp voor tekst). Centralisatie van afmetingen in dimens.xml vereenvoudigt het onderhoud: het wijzigen van één waarde in dimens.xml werkt de afmeting bij op alle schermen van de app. Er kunnen gekwalificeerde dimens.xml-bestanden worden gemaakt voor verschillende dichtheden (values-hdpi, values-xhdpi). Volgens Android Jetpack Docs (2025) raadt Google aan om in dimens.xml spaties (margin, padding), elementbreedtes (constanten), avatarafmetingen en toolbarhoogte op te slaan.

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

In dit bestand heeft elke dimen een naam en waarde. Gebruik in XML-bestanden: @dimen/avatar_size. Volgens Material Design Guidelines (2025) is de basisstap van het raster in Android 8 dp (8-point grid). Alle spaties, elementafmetingen en afstanden moeten een veelvoud zijn van 8 dp: 8, 16, 24, 32, 48, 56, 64, 72 dp. Voor tekst is de stap 4 sp.

Programmatisch gebruik van dp in Kotlin en XML

In XML-bestanden wordt dp direct gebruikt: android:layout_width="48dp". In programmacode (Kotlin/Java) moet dp worden geconverteerd naar px met behulp van TypedResource of extensiefuncties. TypedResource biedt kant-en-klare methoden voor het werken met dp tijdens runtime: getDimensionPixelSize() retourneert een geheel getal px. In Jetpack Compose is dp de standaard meeteenheid in modifiers en layoutcontainers.

// Conversie van dp naar px programmatisch
fun Context.dpToPx(dp: Int): Int {
    return (dp * resources
        .displayMetrics
        .density).toInt()
}

// Gebruik in Activity
val paddingPx = dpToPx(16)
button.setPadding(
    paddingPx,
    paddingPx,
    paddingPx,
    paddingPx,
)

// Jetpack Compose: dp als ingebouwde eenheid
Modifier
    .padding(16.dp)
    .size(48.dp)

In dit voorbeeld is dpToPx() — een extensiefunctie voor Context, die dp naar px converteert met behulp van displayMetrics.density. In Jetpack Compose is dp ingebouwd in het typesysteem en vereist het geen handmatige conversie — de compiler vertaalt automatisch dp naar px in de renderfase.

XML-bestanden met 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"
/>

In XML wordt dp als achtervoegsel aan het getal toegevoegd — margin_top="16dp". Voor tekst wordt sp gebruikt — textSize="@dimen/text_size_body". De verwijzing @dimen maakt gecentraliseerd beheer van waarden mogelijk. Het gebruik van match_parent voor breedte en 48dp voor hoogte is een standaard Material Design patroon voor knoppen.

Typische fouten bij het gebruik van dp

Volgens een analyse van Android-apps door Google Play Console (2025) zijn de vijf meest voorkomende fouten: het gebruik van px in plaats van dp in XML-bestanden, het ontbreken van dimens.xml (waarden inline geschreven), onjuiste conversie van dp naar px in code (gebruik van gehele deling), het negeren van sp voor tekst en het geen rekening houden met systeeminstellingen voor lettergrootte via sp. Gehele deling is de gevaarlijkste fout: in Kotlin val px = dp * density — als dp en density Int zijn, zal het resultaat ook Int zijn en gaat de precisie verloren.

• px in plaats van dp — de app ziet er anders uit op apparaten met verschillende dichtheid. Oplossing: vervang px door dp in XML.
• Inline waarden — afmetingen direct in layout-bestanden geschreven. Duplicatie van waarden bemoeilijkt onderhoud en updates.
• sp voor tekst — het gebruik van dp voor lettergrootte negeert gebruikersinstellingen en schendt de toegankelijkheid.
• Gehele deling — in Kotlin geeft deling van Int door Int een Int, waarbij het breukdeel verloren gaat. Gebruik altijd Float.