dp — basics, density-independent pixels in Android

What is dp in Android?

dp (density-independent pixel) is a virtual unit of measurement in Android, introduced to unify UI element sizes on devices with different pixel densities. One dp is approximately equal to one physical pixel on a screen with 160 dpi density (mdpi). On a screen with 320 dpi density (xhdpi), 1 dp equals 2 physical pixels. Thus, the physical size of an element on the screen remains the same — about 1/160 inch. According to Android Developers (2025), dp is the only unit of measurement that should be used for layout, padding, margin and view width/height dimensions.

Why you should not use px

If you set a button width to 160 px, on an mdpi screen it will be 1 inch wide, but on an xxxhdpi screen (640 dpi) — only 0.25 inches. dp solves this problem: 160 dp on any screen will equal 1 inch. Android automatically converts dp to px via DisplayMetrics.density during rendering. According to the Android Developer Blog (2025), before the introduction of dp (Android 1.0), developers manually calculated px offsets, which led to constant bugs when porting.

dp, px and sp: what's the difference

dp, px and sp are three units of measurement in Android, each with its own purpose. px is a physical screen pixel that depends on density. dp is a density-independent pixel for element dimensions. sp is a scale-independent pixel for text that additionally takes into account system font size settings. According to Material Design (2025), the difference between dp and sp is a key accessibility point: users with poor eyesight increase font size, and sp values adjust automatically, while dp does not.

Formula for converting dp to px and vice versa

The conversion formula for dp to px: px = dp × (dpi / 160). For reverse conversion: dp = px / (dpi / 160). density is the ratio dpi / 160, which Android calculates based on DisplayMetrics. On mdpi density = 1.0, on hdpi = 1.5, on xhdpi = 2.0, on xxhdpi = 3.0, on xxxhdpi = 4.0. Thus, 48 dp in pixels: on mdpi — 48 px, on xxhdpi — 144 px. According to Google I/O 2024, this formula can be used for approximate conversion of iOS pt (points) to dp — 1 pt ≈ 1 dp.

dimens.xml: centralized dimension management

dimens.xml is an Android resource file in res/values/, intended for storing all dimensions in dp (and sp for text). Centralizing dimensions in dimens.xml simplifies maintenance: changing one value in dimens.xml updates the size across all application screens. You can create qualified dimens.xml files for different densities (values-hdpi, values-xhdpi). According to Android Jetpack Docs (2025), Google recommends storing margins, padding, element widths (constants), avatar sizes, and toolbar height in 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>

In this file, each dimen has a name and a value. Usage in XML markup: @dimen/avatar_size. According to Material Design Guidelines (2025), the basic grid step in Android is 8 dp (8-point grid). All margins, element sizes, and distances should be multiples of 8 dp: 8, 16, 24, 32, 48, 56, 64, 72 dp. For text, the step is 4 sp.

Programmatic use of dp in Kotlin and XML

In XML markup, dp is used directly: android:layout_width="48dp". In programmatic code (Kotlin/Java), you need to convert dp to px using TypedResource or extension functions. TypedResource provides ready-made methods for working with dp at runtime: getDimensionPixelSize() returns an integer px value. In Jetpack Compose, dp is the standard unit of measurement in modifiers and layout containers.

// Converting dp to px programmatically
fun Context.dpToPx(dp: Int): Int {
    return (dp * resources
        .displayMetrics
        .density).toInt()
}

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

// Jetpack Compose: dp as a built-in unit
Modifier
    .padding(16.dp)
    .size(48.dp)

In this example, dpToPx() is an extension function for Context, converting dp to px using displayMetrics.density. In Jetpack Compose, dp is built into the type system and does not require manual conversion — the compiler automatically translates dp to px at the rendering stage.

XML markup with 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, dp is specified as a suffix to the number — margin_top="16dp". For text, sp is used — textSize="@dimen/text_size_body". The @dimen reference allows centralized value management. Using match_parent for width and 48dp for height is a standard Material Design pattern for buttons.

Common mistakes when using dp

According to an analysis of Android applications from Google Play Console (2025), the five most common mistakes are: using px instead of dp in XML markup, missing dimens.xml (values written inline), incorrect dp to px conversion in code (using integer division), ignoring sp for text, and not accounting for system font size settings via sp. Integer division is the most dangerous mistake: in Kotlin val px = dp * density — if dp and density are Int, the result will also be Int, and precision is lost.

• px instead of dp — the application looks different on devices with different densities. Fixed by replacing px with dp in XML.
• Inline values — dimensions are written directly in layout files. Duplicating values complicates maintenance and updates.
• sp for text — using dp for font size ignores user settings, breaking accessibility.
• Integer division — in Kotlin, dividing Int by Int yields Int, losing the fractional part. Always use Float.