dp — bases, pixels indépendants de la densité sous Android

Qu'est-ce que dp sous Android ?

dp (pixel indépendant de la densité) est une unité de mesure virtuelle sous Android, introduite pour unifier les tailles des éléments d'interface sur les appareils avec différentes densités de pixels. Un dp équivaut approximativement à un pixel physique sur un écran avec une densité de 160 dpi (mdpi). Sur un écran avec une densité de 320 dpi (xhdpi), 1 dp équivaut à 2 pixels physiques. Ainsi, la taille physique d'un élément à l'écran reste la même — environ 1/160 de pouce. Selon Android Developers (2025), dp est la seule unité de mesure qui devrait être utilisée pour les dimensions de layout, padding, margin et la largeur/hauteur des vues.

Pourquoi ne pas utiliser px

Si vous définissez la largeur d'un bouton à 160 px, sur un écran mdpi il fera 1 pouce de large, mais sur un écran xxxhdpi (640 dpi) — seulement 0,25 pouce. dp résout ce problème : 160 dp sur n'importe quel écran équivaudront à 1 pouce. Android convertit automatiquement dp en px via DisplayMetrics.density lors du rendu. Selon Android Developer Blog (2025), avant l'introduction de dp (Android 1.0), les développeurs calculaient manuellement les décalages en px, ce qui entraînait des bogues constants lors du portage.

dp, px et sp : quelle est la différence

dp, px et sp sont trois unités de mesure sous Android, chacune avec son propre objectif. px est un pixel physique d'écran qui dépend de la densité. dp est un pixel indépendant de la densité pour les dimensions des éléments. sp est un pixel indépendant de l'échelle pour le texte qui prend également en compte les paramètres de taille de police du système. Selon Material Design (2025), la différence entre dp et sp est un point clé d'accessibilité : les utilisateurs malvoyants augmentent la taille de la police, et les valeurs sp s'ajustent automatiquement, contrairement à dp.

Formule de conversion de dp en px et vice versa

La formule de conversion de dp en px : px = dp × (dpi / 160). Pour la conversion inverse : dp = px / (dpi / 160). density est le rapport dpi / 160, qu'Android calcule à partir de DisplayMetrics. Sur mdpi density = 1,0, sur hdpi = 1,5, sur xhdpi = 2,0, sur xxhdpi = 3,0, sur xxxhdpi = 4,0. Ainsi, 48 dp en pixels : sur mdpi — 48 px, sur xxhdpi — 144 px. Selon Google I/O 2024, cette formule peut être utilisée pour la conversion approximative des pt (points) iOS en dp — 1 pt ≈ 1 dp.

dimens.xml : gestion centralisée des dimensions

dimens.xml est un fichier de ressources Android dans res/values/, destiné à stocker toutes les dimensions en dp (et sp pour le texte). Centraliser les dimensions dans dimens.xml simplifie la maintenance : modifier une valeur dans dimens.xml met à jour la taille sur tous les écrans de l'application. Vous pouvez créer des fichiers dimens.xml qualifiés pour différentes densités (values-hdpi, values-xhdpi). Selon Android Jetpack Docs (2025), Google recommande de stocker les marges, le padding, les largeurs d'éléments (constantes), les tailles d'avatar et la hauteur de la barre d'outils dans 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>

Dans ce fichier, chaque dimen a un nom et une valeur. Utilisation dans le balisage XML : @dimen/avatar_size. Selon Material Design Guidelines (2025), le pas de grille de base sous Android est de 8 dp (grille à 8 points). Toutes les marges, tailles d'éléments et distances doivent être des multiples de 8 dp : 8, 16, 24, 32, 48, 56, 64, 72 dp. Pour le texte, le pas est de 4 sp.

Utilisation programmatique de dp en Kotlin et XML

Dans le balisage XML, dp est utilisé directement : android:layout_width="48dp". Dans le code programmatique (Kotlin/Java), vous devez convertir dp en px à l'aide de TypedResource ou de fonctions d'extension. TypedResource fournit des méthodes prêtes à l'emploi pour travailler avec dp au moment de l'exécution : getDimensionPixelSize() retourne une valeur entière en px. Dans Jetpack Compose, dp est l'unité de mesure standard dans les modificateurs et les conteneurs de mise en page.

// Conversion programmatique de dp en px
fun Context.dpToPx(dp: Int): Int {
    return (dp * resources
        .displayMetrics
        .density).toInt()
}

// Utilisation dans Activity
val paddingPx = dpToPx(16)
button.setPadding(
    paddingPx,
    paddingPx,
    paddingPx,
    paddingPx,
)

// Jetpack Compose : dp comme unité intégrée
Modifier
    .padding(16.dp)
    .size(48.dp)

Dans cet exemple, dpToPx() est une fonction d'extension pour Context, convertissant dp en px à l'aide de displayMetrics.density. Dans Jetpack Compose, dp est intégré au système de types et ne nécessite pas de conversion manuelle — le compilateur traduit automatiquement dp en px lors de l'étape de rendu.

Balisage XML avec 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 est spécifié comme suffixe du nombre — margin_top="16dp". Pour le texte, sp est utilisé — textSize="@dimen/text_size_body". La référence @dimen permet une gestion centralisée des valeurs. L'utilisation de match_parent pour la largeur et de 48dp pour la hauteur est un modèle Material Design standard pour les boutons.

Erreurs courantes lors de l'utilisation de dp

Selon une analyse des applications Android de Google Play Console (2025), les cinq erreurs les plus courantes sont : l'utilisation de px au lieu de dp dans le balisage XML, l'absence de dimens.xml (valeurs écrites en ligne), la conversion incorrecte de dp en px dans le code (utilisation de la division entière), l'ignorance de sp pour le texte et la non-prise en compte des paramètres de taille de police système via sp. La division entière est l'erreur la plus dangereuse : en Kotlin val px = dp * density — si dp et density sont Int, le résultat sera également Int, et la précision est perdue.

• px au lieu de dp — l'application a un aspect différent sur des appareils avec des densités différentes. Se corrige en remplaçant px par dp dans le XML.
• Valeurs en ligne — les dimensions sont écrites directement dans les fichiers de mise en page. La duplication des valeurs complique la maintenance et les mises à jour.
• sp pour le texte — l'utilisation de dp pour la taille de police ignore les paramètres de l'utilisateur, brisant l'accessibilité.
• Division entière — en Kotlin, diviser Int par Int donne Int, perdant la partie fractionnaire. Utilisez toujours Float.