dp — grunder, densitetsoberoende pixlar i Android

Vad är dp i Android?

dp (density-independent pixel) — är en virtuell måttenhet i Android, införd för att enhetliggöra storleken på UI-element på enheter med olika pixeldensitet. En dp är ungefär lika med en fysisk pixel på en skärm med densiteten 160 dpi (mdpi). På en skärm med densiteten 320 dpi (xhdpi) kommer 1 dp att vara lika med 2 fysiska pixlar. På så sätt förblir elementets fysiska storlek på skärmen densamma — cirka 1/160 tum. Enligt Android Developers (2025) är dp den enda måttenhet som ska användas för layout, padding, margin och bredd/höjd på vyer.

Varför px inte kan användas

Om du ställer in bredden på en knapp till 160 px, på en mdpi-skärm kommer den att vara 1 tum bred, och på en xxxhdpi-skärm (640 dpi) — endast 0,25 tum. dp löser detta problem: 160 dp på vilken skärm som helst kommer att vara lika med 1 tum. Android konverterar automatiskt dp till px via DisplayMetrics.density vid rendering. Enligt Android Developer Blog (2025) använde utvecklare före införandet av dp (Android 1.0) px manuellt, vilket ledde till ständiga buggar vid portning.

dp, px och sp: vad är skillnaden

dp, px och sp — tre måttenheter i Android, var och en med sitt syfte. px — skärmens fysiska pixel, som beror på densiteten. dp — densitetsoberoende pixel för elementstorlekar. sp — scale-independent pixel för text, som även tar hänsyn till systeminställningar för teckenstorlek. Enligt Material Design (2025) är skillnaden mellan dp och sp en viktig aspekt av tillgänglighet: användare med dålig syn förstorar teckensnittet och sp-värden anpassas automatiskt, medan dp — inte.

Formel för konvertering av dp till px och tillbaka

Konverteringsformel dp till px: px = dp × (dpi / 160). För omvänd konvertering: dp = px / (dpi / 160). density — förhållandet dpi / 160, som Android beräknar baserat på DisplayMetrics. På mdpi density = 1.0, på hdpi = 1.5, på xhdpi = 2.0, på xxhdpi = 3.0, på xxxhdpi = 4.0. Alltså 48 dp i pixlar: på mdpi — 48 px, på xxhdpi — 144 px. Enligt Google I/O 2024 kan denna formel användas för ungefärlig konvertering av iOS pt (points) till dp — 1 pt ≈ 1 dp.

dimens.xml: centraliserad storlekshantering

dimens.xml — Android-resursfil i res/values/, avsedd för lagring av alla mått i dp (och sp för text). Centralisering av mått i dimens.xml förenklar underhållet: en ändring av ett värde i dimens.xml uppdaterar storleken på alla skärmar i appen. Kvalificerade dimens.xml-filer kan skapas för olika densiteter (values-hdpi, values-xhdpi). Enligt Android Jetpack Docs (2025) rekommenderar Google att lagra i dimens.xml mellanrum (margin, padding), elementbredder (konstanter), avatarstorlekar och verktygsfältshöjd.

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

I denna fil har varje dimen ett namn och ett värde. Användning i XML-filer: @dimen/avatar_size. Enligt Material Design Guidelines (2025) är grundsteget för rutnätet i Android 8 dp (8-point grid). Alla mellanrum, elementstorlekar och avstånd bör vara multiplar av 8 dp: 8, 16, 24, 32, 48, 56, 64, 72 dp. För text är steget 4 sp.

Programmatisk användning av dp i Kotlin och XML

I XML-filer används dp direkt: android:layout_width="48dp". I programkod (Kotlin/Java) måste dp konverteras till px med hjälp av TypedResource eller tilläggsfunktioner. TypedResource tillhandahåller färdiga metoder för att arbeta med dp vid körning: getDimensionPixelSize() returnerar ett heltal px. I Jetpack Compose är dp standardmåttenheten i modifierare och layout-containrar.

// Programmatisk konvertering av dp till px
fun Context.dpToPx(dp: Int): Int {
    return (dp * resources
        .displayMetrics
        .density).toInt()
}

// Användning i Activity
val paddingPx = dpToPx(16)
button.setPadding(
    paddingPx,
    paddingPx,
    paddingPx,
    paddingPx,
)

// Jetpack Compose: dp som inbyggd enhet
Modifier
    .padding(16.dp)
    .size(48.dp)

I detta exempel är dpToPx() — en tilläggsfunktion för Context, som konverterar dp till px med hjälp av displayMetrics.density. I Jetpack Compose är dp inbyggt i typsystemet och kräver ingen manuell konvertering — kompilatorn översätter automatiskt dp till px i renderingsfasen.

XML-filer med 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"
/>

I XML läggs dp till som suffix till talet — margin_top="16dp". För text används sp — textSize="@dimen/text_size_body". Referensen @dimen möjliggör centraliserad hantering av värden. Användning av match_parent för bredd och 48dp för höjd är ett standardmönster i Material Design för knappar.

Typiska misstag vid användning av dp

Enligt analys av Android-appar från Google Play Console (2025) är de fem vanligaste misstagen: användning av px istället för dp i XML-filer, avsaknad av dimens.xml (värden inline skrivna), felaktig konvertering av dp till px i kod (användning av heltalsdivision), ignorering av sp för text och att inte ta hänsyn till systeminställningar för teckenstorlek via sp. Heltalsdivision är det farligaste misstaget: i Kotlin val px = dp * density — om dp och density är Int, blir resultatet också Int och precisionen går förlorad.

• px istället för dp — appen ser olika ut på enheter med olika densitet. Åtgärd: ersätt px med dp i XML.
• Inline-värden — måtten är direkt inskrivna i layout-filer. Duplicering av värden försvårar underhåll och uppdatering.
• sp för text — användning av dp för teckenstorlek ignorerar användarinställningar och bryter mot tillgänglighet.
• Heltalsdivision — i Kotlin ger division av Int med Int ett Int, bråkdelen går förlorad. Använd alltid Float.