Quelle est la différence entre les unités de mesure Android?

• px
• tremper
• dp
• sp

Dans la documentation pour les développeurs Android :

1. px
   Pixels - correspond aux pixels réels sur l'écran.

2. en
   pouces - en fonction de la taille physique de l'écran.
   1 pouce = 2,54 centimètres

3. mm
   Millimètres - basé sur la taille physique de l'écran.

4. pt
   points - 1/72 de pouce en fonction de la taille physique de l'écran.

5. dp ou dip Pixels indépendants de la
   densité - unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi, donc un dp est un pixel sur un écran de 160 dpi. Le rapport dp / pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. Remarque: Le compilateur accepte à la fois "dip" et "dp", bien que "dp" soit plus cohérent avec "sp".

6. sp Pixels indépendants de l'
   échelle - c'est comme l'unité dp, mais elle est également mise à l'échelle par la préférence de taille de police de l'utilisateur. Il est recommandé d'utiliser cet appareil lors de la spécification des tailles de police, afin qu'elles soient ajustées à la fois pour la densité de l'écran et les préférences de l'utilisateur.

De Comprendre l'indépendance de la densité dans Android :

+----------------+----------------+---------------+-------------------------------+
| Density Bucket | Screen Density | Physical Size | Pixel Size                    | 
+----------------+----------------+---------------+-------------------------------+
| ldpi           | 120 dpi        | 0.5 x 0.5 in  | 0.5 in * 120 dpi = 60x60 px   | 
+----------------+----------------+---------------+-------------------------------+
| mdpi           | 160 dpi        | 0.5 x 0.5 in  | 0.5 in * 160 dpi = 80x80 px   | 
+----------------+----------------+---------------+-------------------------------+
| hdpi           | 240 dpi        | 0.5 x 0.5 in  | 0.5 in * 240 dpi = 120x120 px | 
+----------------+----------------+---------------+-------------------------------+
| xhdpi          | 320 dpi        | 0.5 x 0.5 in  | 0.5 in * 320 dpi = 160x160 px | 
+----------------+----------------+---------------+-------------------------------+
| xxhdpi         | 480 dpi        | 0.5 x 0.5 in  | 0.5 in * 480 dpi = 240x240 px | 
+----------------+----------------+---------------+-------------------------------+
| xxxhdpi        | 640 dpi        | 0.5 x 0.5 in  | 0.5 in * 640 dpi = 320x320 px | 
+----------------+----------------+---------------+-------------------------------+

+---------+-------------+---------------+-------------+--------------------+
| Unit    | Description | Units Per     | Density     | Same Physical Size | 
|         |             | Physical Inch | Independent | On Every Screen    | 
+---------+-------------+---------------+-------------+--------------------+
| px      | Pixels      | Varies        | No          | No                 | 
+---------+-------------+---------------+-------------+--------------------+
| in      | Inches      | 1             | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| mm      | Millimeters | 25.4          | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| pt      | Points      | 72            | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| dp      | Density     | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+
| sp      | Scale       | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Vous trouverez également plus d'informations dans la documentation de conception de Google .

À peu près tout à ce sujet et comment obtenir le meilleur support pour plusieurs écrans de différentes tailles et densités est très bien documenté ici:

• Prise en charge de plusieurs écrans

Taille d'écran Taille
physique réelle, mesurée en diagonale de l'écran. Pour plus de simplicité, Android regroupe toutes les tailles d'écran réelles en quatre tailles généralisées: petite, normale, grande et extra-large.

Densité d'écran
Le nombre de pixels dans une zone physique de l'écran; généralement appelé dpi (points par pouce). Par exemple, un écran à densité "faible" a moins de pixels dans une zone physique donnée, par rapport à un écran à densité "normale" ou "élevée". Pour plus de simplicité, Android regroupe toutes les densités d'écran réelles en six densités généralisées: faible, moyenne, élevée, extra-haute, extra-extra-haute et extra-extra-extra-haute.

Orientation
Orientation de l'écran du point de vue de l'utilisateur. Il s'agit de paysage ou de portrait, ce qui signifie que le rapport d'aspect de l'écran est respectivement large ou haut. Sachez que non seulement différents appareils fonctionnent par défaut dans différentes orientations, mais que l'orientation peut changer lors de l'exécution lorsque l'utilisateur fait pivoter l'appareil.

Résolution
Nombre total de pixels physiques sur un écran. Lors de l'ajout de la prise en charge de plusieurs écrans, les applications ne fonctionnent pas directement avec la résolution; les applications ne devraient porter que sur la taille et la densité de l'écran, comme spécifié par les groupes de taille et de densité généralisés.

Pixel indépendant de la densité (dp)
Unité de pixel virtuel que vous devez utiliser lors de la définition de la disposition de l'interface utilisateur pour exprimer les dimensions ou la position de la disposition de manière indépendante de la densité. Le pixel indépendant de la densité équivaut à un pixel physique sur un écran à 160 dpi, qui est la densité de base supposée par le système pour un écran à densité "moyenne". Au moment de l'exécution, le système gère de manière transparente toute mise à l'échelle des unités dp, si nécessaire, en fonction de la densité réelle de l'écran utilisé. La conversion des unités de dp aux pixels de l' écran est simple: px = dp * (dpi / 160). Par exemple, sur un écran à 240 dpi, 1 dp équivaut à 1,5 pixels physiques. Vous devez toujours utiliser des unités dp lors de la définition de l'interface utilisateur de votre application, afin d'assurer un affichage correct de votre interface utilisateur sur des écrans de densités différentes.

Si vous envisagez sérieusement de développer une application Android pour plus d'un type d'appareil, vous devriez avoir lu au moins une fois le document de développement de prise en charge des écrans. En plus de cela, c'est toujours une bonne chose de connaître le nombre réel de périphériques actifs qui ont une configuration d'écran particulière.

• Tailles et densités d'écran

Je développerai davantage sur la façon dont dp se convertit exactement en px:

• Si elle s'exécute sur un périphérique mdpi, une 150 x 150 pximage prendra 150 * 150 dpde l'espace sur l'écran.
• Si elle est exécutée sur un périphérique hdpi, une 150 x 150 pximage prendra 100 * 100 dpde l'espace sur l'écran.
• Si elle s'exécute sur un périphérique xhdpi, une 150x150 pximage prendra 75 * 75 dpde l'espace sur l'écran.

L'autre sens: disons, vous voulez ajouter une image à votre application et vous en avez besoin pour remplir un 100 * 100 dpcontrôle. Vous devrez créer des images de tailles différentes pour les tailles d'écran prises en charge:

• 100 * 100 px image pour mdpi
• 150 * 150 px image pour hdpi
• 200 * 200 px image pour xhdpi

px - Pixels - le point par échelle correspond aux pixels réels sur l'écran.

i - Pouces - basé sur la taille physique de l'écran.

mm - Millimètres - basé sur la taille physique de l'écran.

pt - Points - 1/72 de pouce basé sur la taille physique de l'écran.

dp - Pixels indépendants de la densité - une unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi, donc on dpest un pixel sur un écran de 160 dpi. Le rapport dp / pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. Remarque: Le compilateur accepte les deux dipet dp, bien qu'il dpsoit plus cohérent avec sp.

sp - Pixels indépendants de l'échelle - c'est comme ledp unité, mais il est également mis à l'échelle par la préférence de taille de police de l'utilisateur. Il est recommandé d'utiliser cet appareil lors de la spécification des tailles de police, afin qu'elles soient ajustées à la fois pour la densité de l'écran et les préférences de l'utilisateur.

Prenons l'exemple de deux écrans de même taille, mais l'un a une densité d'écran de 160 dpi (points par pouce, c'est-à-dire des pixels par pouce) et l'autre est de 240 dpi.

                          Lower resolution screen     Higher resolution, same size
Physical Width                      1.5 inches                        1.5 inches
Dots Per Inch (“dpi”)               160                               240
Pixels (=width*dpi)                 240                               360
Density (factor of baseline 160)    1.0                               1.5

Density-independent pixels          240                               240
(“dip” or “dp” or “dps”)

Scale-independent pixels 
 (“sip” or “sp”)                  Depends on user font size settings    same

De plus, vous devez avoir une compréhension claire des concepts suivants:

Taille de l'écran:

Taille physique réelle, mesurée en diagonale de l'écran. Pour plus de simplicité, Android regroupe toutes les tailles d'écran réelles en quatre tailles généralisées: petite, normale, grande et très grande.

Densité d'écran:

La quantité de pixels dans une zone physique de l'écran; généralement appelé dpi (points par pouce). Par exemple, un écran à densité "faible" a moins de pixels dans une zone physique donnée, par rapport à un écran à densité "normale" ou "élevée". Pour plus de simplicité, Android regroupe toutes les densités d'écran réelles en quatre densités généralisées: faible, moyenne, élevée et extra élevée.

Orientation:

L'orientation de l'écran du point de vue de l'utilisateur. Il s'agit de paysage ou de portrait, ce qui signifie que le rapport d'aspect de l'écran est respectivement large ou haut. Sachez que non seulement différents appareils fonctionnent par défaut dans différentes orientations, mais que l'orientation peut changer lors de l'exécution lorsque l'utilisateur fait pivoter l'appareil.

Résolution:

Nombre total de pixels physiques sur un écran. Lors de l'ajout de la prise en charge de plusieurs écrans, les applications ne fonctionnent pas directement avec la résolution; les applications ne devraient porter que sur la taille et la densité de l'écran, comme spécifié par les groupes de taille et de densité généralisés.

Pixel indépendant de la densité (dp):

Unité de pixels virtuels que vous devez utiliser lors de la définition de la disposition de l'interface utilisateur pour exprimer les dimensions ou la position de la disposition de manière indépendante de la densité. Le pixel indépendant de la densité équivaut à un pixel physique sur un écran à 160 dpi, qui est la densité de base supposée par le système pour un écran à densité "moyenne". Au moment de l'exécution, le système gère de manière transparente toute mise à l'échelle des unités dp, si nécessaire, en fonction de la densité réelle de l'écran utilisé. La conversion des unités dp en pixels d'écran est simple: px = dp * (dpi / 160). Par exemple, sur un écran à 240 dpi, 1 dp équivaut à 1,5 pixels physiques. Vous devez toujours utiliser des unités dp lors de la définition de l'interface utilisateur de votre application, afin d'assurer un affichage correct de votre interface utilisateur sur des écrans de densités différentes.

Référence: site des développeurs Android

dpest dip. Utilisez-le pour tout (marge, rembourrage, etc.).

À utiliser sppour {text-size} uniquement.

Pour obtenir la même taille sur différentes densités d'écran, Android convertit ces unités en pixels au moment de l'exécution, il n'y a donc pas de calculs difficiles à faire.

Voyez la différence entre px, dpet spsur différentes tailles d'écran.

Source: Programmation Android: The Big Nerd Ranch Guide

J'ai calculé la formule ci-dessous pour effectuer les conversions dpivers dpetsp

Définitions

px ou dot est un pixel sur l'écran physique.

Les dpi sont des pixels par pouce sur l'écran physique et représentent la densité de l'affichage.

Android donne noms d'alias à plusieurs densités

• ldpi (faible) ~ 120 dpi
• mdpi (moyen) ~ 160dpi
• hdpi (élevé) ~ 240 dpi
  • la plupart des appareils en 2015 sont ici
• xhdpi (extra-haute) ~ 320dpi
  • Apple iPhone 4/5/6, Nexus 4
• xxhdpi (extra-extra-élevé) ~ 480 dpi
  • Nexus 5
• xxxhdpi (extra-extra-extra-élevé) ~ 640 dpi

dip ou dp sont des pixels indépendants de la densité , c'est-à-dire qu'ils correspondent à plus ou moins de pixels en fonction de la densité physique.

• 1dp = 1px sur mdpi

sp ou sip est un pixel indépendant de l'échelle . Ils sont mis à l'échelle lorsque l' option Grand texte est activée dans Settings>Accessibility

• 1sp = 1dp
• 1sp = 1.2dp avec accessibilité Grand texte

Que faut-il utiliser?

Utilisez sp pour la taille du texte.

Utilisez dp pour tout le reste.

Source 1

Source 2

Source 3 : (les données de la source 3 sont données ci-dessous)

Ce sont des valeurs de dimension définies en XML. Une dimension est spécifiée avec un nombre suivi d'une unité de mesure. Par exemple: 10px, 2in, 5sp. Les unités de mesure suivantes sont prises en charge par Android:

dp

Pixels indépendants de la densité - Unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi (points par pouce), sur lequel 1dp est à peu près égal à 1px. Lors de l'exécution sur un écran de densité plus élevée, le nombre de pixels utilisés pour dessiner 1dp est augmenté d'un facteur approprié pour le dpi de l'écran. De même, sur un écran de densité inférieure, le nombre de pixels utilisés pour 1dp est réduit. Le rapport dp / pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. L'utilisation d'unités dp (au lieu d'unités px) est une solution simple pour redimensionner correctement les dimensions de la vue dans votre mise en page pour différentes densités d'écran. En d'autres termes, il assure la cohérence des tailles réelles de vos éléments d'interface utilisateur sur différents appareils.

sp

Pixels indépendants de l'échelle - C'est comme l'unité dp, mais elle est également mise à l'échelle par la préférence de taille de police de l'utilisateur. Il est recommandé d'utiliser cet appareil lors de la spécification des tailles de police, afin qu'elles soient ajustées à la fois pour la densité de l'écran et les préférences de l'utilisateur.

pt

Points - 1/72 de pouce en fonction de la taille physique de l'écran.

px

Pixels - Correspond aux pixels réels sur l'écran. Cette unité de mesure n'est pas recommandée car la représentation réelle peut varier d'un appareil à l'autre; chaque appareil peut avoir un nombre différent de pixels par pouce et peut avoir plus ou moins de pixels totaux disponibles sur l'écran.

mm

Millimètres - Basé sur la taille physique de l'écran.

dans

Pouces - Basé sur la taille physique de l'écran.

Remarque: Une dimension est une ressource simple qui est référencée à l'aide de la valeur fournie dans l'attribut name (pas le nom du fichier XML). En tant que tel, vous pouvez combiner des ressources de dimension avec d'autres ressources simples dans un seul fichier XML, sous un élément.

Fondamentalement, le seul moment où le px s'applique est un px, et c'est si vous voulez exactement un pixel à l'écran comme dans le cas d'un diviseur:

Sur> 160 dpi, vous pouvez obtenir 2-3 pixels,

Sur> 120 dpi, il arrondit à 0.

px

Pixels - correspond aux pixels réels sur l'écran.

dp ou dip

Pixels indépendants de la densité - unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi, donc un dp est un pixel sur un écran de 160 dpi.

Utilisation de dp:

Indépendance de densité - Votre application atteint «l'indépendance de densité» lorsqu'elle préserve la taille physique (du point de vue de l'utilisateur) des éléments de l'interface utilisateur lorsqu'ils sont affichés sur des écrans de densités différentes. (c.-à-d.) L'image doit avoir la même taille (pas agrandie ou rétrécie) dans différents types d'écrans.

sp

Pixels indépendants de l'échelle - c'est comme l'unité dp, mais elle est également mise à l'échelle par la préférence de taille de police de l'utilisateur.

http://developer.android.com/guide/topics/resources/more-resources.html#Dimension

Où utiliser quoi et la relation entre px et dp?

Pixel indépendant de la densité (dp)

Unité de pixels virtuels que vous devez utiliser lors de la définition de la mise en page de l'interface utilisateur pour exprimer les dimensions ou la position de la mise en page de manière indépendante de la densité. Comme décrit ci-dessus, le pixel indépendant de la densité équivaut à un pixel physique sur un écran à 160 dpi, qui est la densité de base supposée par le système pour un écran à densité "moyenne". Au moment de l'exécution, le système gère de manière transparente toute mise à l'échelle des unités dp, si nécessaire, en fonction de la densité réelle de l'écran utilisé. La conversion des unités dp en pixels d'écran est simple:

px = dp * (dpi / 160).

Par exemple, sur un écran à 240 dpi, 1 dp équivaut à 1,5 pixels physiques. Vous devez toujours utiliser des unités dp lors de la définition de l'interface utilisateur de votre application, afin d'assurer un affichage correct de votre interface utilisateur sur des écrans de densités différentes.

Comprendre le pixel en dp et vice versa est très essentiel (en particulier pour donner des valeurs de dp exactes à l'équipe créative)

dp = px * 160 / dpi

MDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp
For example, if you want to convert 20 pixel to dp, use the above formula,
dp = 20 * 160 / 160 = 20.
So, 20 pixel = 20 dp.

HDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp
XHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp
XXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp

For example, let us consider Nexus 4.
If 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can
convert it to dp easily by the following calculation :
dp = 24 * 160 / 320 = 12 dp
Screen dimension:
768 x 1280 pixel resolution (320 ppi or 320dpi)
Optional (screen size):
 4.7" diagonal

• Essayez d'obtenir toutes les valeurs de pixels en nombres pairs de l'équipe créative. Sinon, la perte de précision se produira lors de la multiplication par 0,5.

px

C'est expliqué ci-dessus. Essayez d'éviter dans les fichiers de mise en page. Mais il y a des cas où le px est requis. par exemple, ligne de séparation ListView. px est mieux ici pour donner une ligne d'un pixel comme séparateur pour toutes les résolutions d'écran.

sp

Utilisez sp pour les tailles de police. Ensuite, seule la police à l'intérieur de l'application changera alors que la taille des polices de l'appareil changera (c'est-à-dire Affichage -> Polices sur l'appareil). Si vous souhaitez conserver une police de taille statique dans l'application, vous pouvez donner la dimension de la police en dp. Dans un tel cas, cela ne changera jamais. Les développeurs peuvent obtenir une telle exigence pour certains écrans spécifiques, pour cela, les développeurs peuvent utiliser dp au lieu de sp. Dans tous les autres cas, sp est recommandé.

Vous pouvez voir la différence entre pxet à dppartir de l'image ci-dessous, et vous pouvez également constater que le pxet dpne peut pas garantir les mêmes tailles physiques sur les différents écrans.

Tout ce qui concerne la taille du texte et l'apparence doit utiliser spou pt. Alors que tout ce qui concerne la taille des contrôles, les dispositions, etc. doit être utilisé avec dp.

Vous pouvez utiliser à la fois dpet dipà ses emplacements.

Je n'utiliserais que dp.

Il y a beaucoup de discussions sur l'utilisation de "sp" pour les tailles de police, et bien que j'apprécie le point, je ne pense pas que ce soit la bonne chose à faire du point de vue du design. Vous pouvez finir par casser votre conception si l'utilisateur a une sélection de taille de police bancale, et l'utilisateur finira par blâmer l'application , et non ses propres choix de vie.

De plus, si vous prenez une application sp-font sur une tablette à 160 dpi, vous constaterez que tout évolue ... mais votre police, qui va paraître minuscule en comparaison. Ce n'est pas beau.

Bien que l'idée des polices "sp" ait un bon cœur, c'est une mauvaise idée. Restez avec dp pour tout.

sp = pixel indépendant de l'échelle

dp = dip = pixels indépendants de la densité

dpi = points par pouce

Nous devons éviter d'utiliser sp .

Nous devons utiliser dp pour prendre en charge plusieurs écrans.

Android prend en charge différentes résolutions d'écran

• ldpi (faible) ~ 120 dpi
• mdpi (moyen) ~ 160 dpi
• hdpi (élevé) ~ 240 dpi
• xhdpi (extra-haute) ~ 320 dpi
• xxhdpi (extra-extra-élevé) ~ 480 dpi
• xxxhdpi (extra-extra-extra-élevé) ~ 640 dpi

Un périphérique ldpi 120 dp a 120 pixels dans une taille de 1 pouce.

De même pour les autres densités ...

En tant qu'ingénieurs logiciels, nous devrions utiliser cette formule de conversion:

pixel = dp * (densité / 160)

Ainsi, 1 dp de l'appareil à 240 dpi aura = 1 * (240/160) = 3/2 = 1,5 pixels.

Et 1 dp du périphérique 480 dpi aura = 1 * (480/160) = 3 pixels.

En utilisant ces connaissances de 1,5 et 3 pixels, un ingénieur logiciel peut concevoir des dispositions pour différentes densités.

Pour vérifier les paramètres d'écran de n'importe quel appareil:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Toast.makeText(
    this,
    "4:" + metrics.heightPixels + "," + metrics.density + ","
    + metrics.densityDpi, Toast.LENGTH_LONG).show();

La différence entre dpet les spunités mentionnées comme « préférence de taille de police de l'utilisateur » par les réponses copiées à partir de la documentation officielle peut être vue au moment de l'exécution en changeantSettings->Accessibility->Large Text option.

Large TextL'option force le texte à 1.3s'agrandir.

private static final float LARGE_FONT_SCALE = 1.3f;

Bien sûr, cela peut dépendre du fournisseur, car cela réside dans les packages / applications / paramètres .

dpi -

• Points par pouces
• Mesurer la densité de pixels de l'écran.

px - pixel

• Pour mapper les pixels de l'écran

pt - points

• Environ 1/72 de pouce, par rapport à la taille d'écran physique.

pouces - par rapport à la taille d'écran physique (1 pouce = 2,54 cm).

mm- millimètre - par rapport à la taille d'écran physique.

sp - pixel indépendant de l'échelle.

• Basé sur la préférence de taille de police de l'utilisateur.
• La police doit être en «sp».

dip -

• dip == dp
• Pixel indépendant de la densité.
• Elle varie en fonction de la densité d'écran.
• Dans un écran de 160 dpi, 1 dp = 1 pixel.
• Utilisez dp sauf la taille de la police du texte.

En standard, dp et sp sont utilisés. sp pour la taille de la police et dp pour tout le reste.

Formule de conversion des unités:

px = dp * (dpi / 160);

Density Bucket -> Screen Display => Physical Size        => Pixel Size                   

ldpi         -> 120 dpi          => 0.5 x 0.5 in         => 0.5 in * 120 dpi = 60x60 px   

mdpi         -> 160 dpi          => 0.5 x 0.5 in         => 0.5 in * 160 dpi = 80x80 px   

hdpi         -> 240 dpi          => 0.5 x 0.5 in         => 0.5 in * 240 dpi = 120x120 px  

xhdpi        -> 320 dpi          => 0.5 x 0.5 in         => 0.5 in * 320 dpi = 160x160 px  

xxhdpi       -> 480 dpi          => 0.5 x 0.5 in         => 0.5 in * 480 dpi = 240x240 px 

xxxhdpi      -> 640 dpi          => 0.5 x 0.5 in         => 0.5 in * 640 dpi = 320x320 px  

Voici la formule utilisée par Android:

px = dp * (dpi / 160)

Où dpi est l'une des densités d'écran suivantes. Pour une liste de toutes les densités possibles cliquez ici

Il définit les constantes "DENSITY_ *".

• ldpi (faible) ~ 120 dpi
• mdpi (moyen) ~ 160dpi
• hdpi (élevé) ~ 240 dpi
• xhdpi (extra-haute) ~ 320dpi
• xxhdpi (extra-extra-élevé) ~ 480 dpi
• xxxhdpi (extra-extra-extra-élevé) ~ 640 dpi

Pris d' ici .

Cela éliminera une grande partie de la confusion lors de la traduction entre px et dp, si vous connaissez votre dpi d'écran.

Donc, disons que vous voulez une image de 60 dp pour un écran hdpi, alors la taille de pixel physique de 60 dp est:

px = 60 * (240 / 160)

Taille de l' écran en Androidsont regroupées en catégories small, medium, large, extra large, double-extraet triple-extra. La densité d'écran est la quantité de pixels dans une zone (comme le pouce) de l'écran. Il est généralement mesuré en points par pouce (dpi). La densité de l'écran est regroupée en faible, moyenne, élevée et extra haute. La résolution est le nombre total de pixels sur l'écran.

• dp: pixel indépendant de la densité, il varie en fonction de la densité de l'écran. Dans un écran de 160 dpi, 1 dp = 1 pixel. À l'exception de la taille de la police, utilisez toujours dp.
• dip: dip == dp. Dans les versions antérieures d'Android, dip était utilisé et changé plus tard en dp.
• sp: Scale Independent Pixel, mis à l'échelle en fonction de la préférence de taille de police de l'utilisateur. Les polices doivent utiliser sp.
• px: notre pixel standard habituel qui correspond au pixel de l'écran.
• en: pouces, par rapport à la taille d'écran physique.
• mm: millimètres, par rapport à la taille d'écran physique.
• pt: 1/72 de pouce, par rapport à la taille d'écran physique.

Formule de conversion entre les unités

 px = dp * (dpi / 160)

dp à px dans l'appareil

L'exemple suivant peut aider à mieux comprendre. La mise à l'échelle se produit en fonction de la taille du compartiment de 120 (ldpi), 160 (mdpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) et 640 (xxxhdpi). Le rapport suggéré par Google pour la conception est de 3: 4: 6: 8: 12 pour ldpi: mdpi: hdpi: xhdpi: xxhdpi

Une image 150px X 150px occupera,

• 150 dp X 150 dp d'espace d'écran en mdpi
• Espace d'écran 100 dp X 100 dp en hdpi
• 75 dp X 75 dp d'espace d'écran en xhdpi

Vous pouvez utiliser la calculatrice DPI suivante pour fixer vos tailles d'image et autres dimensions lorsque vous souhaitez avoir une conception d'interface utilisateur uniforme sur tous les appareils Android.

Calculatrice DPI en Java

/*
Program output
LDPI: 165.0 X 60.0
MDPI: 220.0 X 80.0
HDPI: 330.0 X 120.0
XHDPI: 440.0 X 160.0
XXHDPI: 660.0 X 240.0
XXXHDPI: 880.0 X 320.0
*/


public class DPICalculator {

private final float LDPI = 120;
private final float MDPI = 160;
private final float HDPI = 240;
private final float XHDPI = 320;
private final float XXHDPI = 480;
private final float XXXHDPI = 640;    

private float forDeviceDensity;
private float width;
private float height;

public DPICalculator(float forDeviceDensity, float width, float height){
    this.forDeviceDensity = forDeviceDensity;
    this.width = width;
    this.height = height;
}

public static void main(String... args) {
    DPICalculator dpiCalculator = new DPICalculator(240,330,120);
    dpiCalculator.calculateDPI();
}


private float getPx(float dp, float value) {
    float px = dp * (value / forDeviceDensity );        
    return px;
}

private void calculateDPI() {

    float ldpiW = getPx(LDPI,width);        
    float ldpiH =  getPx(LDPI,height);
    float mdpiW = getPx(MDPI,width);        
    float mdpiH =  getPx(MDPI,height);        
    float hdpiW = getPx(HDPI,width);        
    float hdpiH =  getPx(HDPI,height);       
    float xdpiW = getPx(XHDPI,width);        
    float xdpiH =  getPx(XHDPI,height);
    float xxdpiW = getPx(XXHDPI,width);        
    float xxdpiH =  getPx(XXHDPI,height);
    float xxxdpiW = getPx(XXXHDPI,width);        
    float xxxdpiH =  getPx(XXXHDPI,height);

    System.out.println("LDPI: " + ldpiW + " X " + ldpiH);
    System.out.println("MDPI: " + mdpiW + " X " + mdpiH);
    System.out.println("HDPI: " + hdpiW + " X " + hdpiH);
    System.out.println("XHDPI: " + xdpiW + " X " + xdpiH);
    System.out.println("XXHDPI: " + xxdpiW + " X " + xxdpiH);
    System.out.println("XXXHDPI: " + xxxdpiW + " X " + xxxdpiH);        
   }
}

Plus d'informations se réfèrent au lien suivant.

http://javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/

Veuillez lire la réponse du wiki de la communauté. Vous trouverez ci-dessous quelques informations à prendre en considération en plus des réponses ci-dessus. La plupart des développeurs Android manquent cela lors du développement d'applications, donc j'ajoute ces points.

sp = pixel indépendant de l'échelle

dp = pixels indépendants de la densité

dpi = densité de pixels

J'ai parcouru les réponses ci-dessus ... ne les trouvant pas exactement correctes. sp pour la taille du texte, dp pour les limites de mise en page - standard. Mais sp pour la taille du texte rompra la mise en page s'il est utilisé avec négligence dans la plupart des appareils.

sp prend la taille du texte de l'appareil, tandis que dp prend celle du standard de densité de l'appareil (ne change jamais dans un appareil) Disons que le texte 100sp peut occuper 80% de l'écran ou 100% de l'écran selon la taille de police définie dans l'appareil

Vous pouvez également utiliser sp pour les limites de mise en page, cela fonctionnera :) Aucune application standard n'utilise sp pour le texte entier

Utilisez sp et dp pour la taille du texte en tenant compte de l'UX.

• Ne pas utiliser sp pour le texte dans la barre d'outils (peut utiliser les dimens android disponibles pour différentes tailles d'écran avec dp)
• N'utilisez pas sp pour le texte dans les petits boutons délimités, le texte très petit, etc.

Certaines personnes utilisent une énorme taille de POLICE dans leur téléphone pour plus de lisibilité, leur donnant un petit texte de taille codée en dur sera un problème UX. Mettez sp pour le texte si nécessaire, mais assurez-vous qu'il ne casse pas la mise en page lorsque l'utilisateur modifie ses paramètres.

De même, si vous avez une seule application prenant en charge toutes les dimensions, l'ajout d'actifs xxxhdpi augmente considérablement la taille de l'application. Mais maintenant, les téléphones xxxhdpi sont courants, nous devons donc inclure au moins les actifs xxxhdpi pour les icônes dans la barre latérale, la barre d'outils et la barre inférieure. Il est préférable de passer aux images vectorielles pour obtenir des images uniformes et de meilleure qualité pour toutes les tailles d'écran.

Notez également que les gens utilisent une police personnalisée dans leur téléphone. L'absence de police peut donc causer des problèmes d'espacement et tout. Supposons que la taille du texte 12sp pour une police personnalisée peut prendre quelques pixels de plus que la police par défaut.

Reportez-vous au site de développeur Google pour obtenir des détails sur les captures d'écran et la densité basée sur Android. https://developer.android.com/training/multiscreen/screendensities

• px - un pixel, identique à ce qui est utilisé en CSS, JavaScript, etc.
• sp - pixels indépendants de l'échelle
• dip - pixels indépendants de la densité

Normalement, sp est utilisé pour les tailles de police, tandis que dip est utilisé (également appelé dp) pour les autres.

Je suis tombé sur un bon article sur la conception d'interface utilisateur d'applications Android pour différentes résolutions d'écran, et je voudrais le laisser ici juste pour quelqu'un qui recherche dans ce domaine. Oui, je sais que c'est en quelque sorte décrit dans Google docs (et mentionné dans les articles ci-dessus), je l'ai lu mais ce n'était pas bon pour moi (ouais, je peux être trop stupide)). Je ne savais pas comment concevoir des mises en page capables de gérer différentes tailles d'écran. Je déteste le concept DP et ainsi de suite, lorsque j'ai besoin d'implémenter une disposition d'interface utilisateur "flexible" pour différents écrans. (Hé les développeurs iOS - oui, vous avez raison, c'est le concept Storyboard).

Android n'a pas un mauvais concept d'interface utilisateur, mais il manque malheureusement les fonctionnalités de Storyboard iOS. Concevoir une interface utilisateur flexible dans Android n'est pas chose facile (au mieux).

Voici l'article qui m'a aidé à comprendre ce qu'il faut faire dans Android pour créer des dispositions pour différentes tailles d'écran:

Blog JMSTUDIO: - Décidez de la taille de l'écran de l'application Android

Comment concevoir l'interface utilisateur pour les applications Android pour différentes tailles d'écran

Pour concevoir une interface utilisateur d'application pour différentes tailles d'écran, notre conception initiale doit respecter un espace minimum requis pour chaque taille d'écran. Android définit une taille minimale (en dp) pour chaque type d'écran généralisé. Voici une directive de taille d'écran Android. Lorsque nous obtenons la taille de l'écran en dp, il ne nous suffit pas de concevoir l'interface utilisateur de l'application Android. Pour chaque taille d'écran, nous devons préparer des graphiques et des images bitmap pour chaque densité. Voici un guide de densité d'écran Android.

Pour un calcul facile, nous pouvons suivre le rapport d'échelle 3: 4: 6: 8 entre les quatre densités généralisées. Si nous créons une image de 36 × 36 pixels pour le périphérique ldpi, la taille des images de densité de repos sera de 48 × 48 pour mdpi, 72 × 72 pour hdpi et 96 × 96 pour xhdpi.

Comment concevoir l'interface utilisateur des applications Android dans Photoshop

De nombreux concepteurs ont des problèmes pour concevoir l'interface utilisateur de l'application Android dans Photoshop ou d'autres outils de conception graphique basés sur les pixels en raison de l'unité indépendante de la densité, dp. Les concepteurs ne savent pas comment mapper dp en pixel. Google ne leur donne pas non plus de guide de conception d'interface utilisateur Android clair, bien qu'ils fournissent une formule de base pour la traduction en dp et en pixels.

Comme définition d'Android, 1pd équivaut à 1px sous 160 dpi (mdpi). Nous voulons donc concevoir une application Android pour un appareil Android xlarge avec une densité mdpi, nous pouvons définir notre taille d'interface utilisateur en pixels comme 960 pixels de largeur et 720px de hauteur; Suivez la même règle de mappage, nous pouvons obtenir les directives de conception de l'interface utilisateur de la taille de l'écran de l'application Android:

AJOUTÉ : Si vous êtes également intéressé par l'interface utilisateur "flexible", jetez un œil à cette bibliothèque: Un SDK Android qui fournit une nouvelle unité de taille - sdp (dp évolutif). Cette unité de taille évolue avec la taille de l'écran (cela est également mentionné dans une réponse ici, à propos de la SDPbibliothèque)

ADDED2 Google a enfin compris l'utilité du concept d'interface utilisateur iOS Storeboard, et c'est parti ConstraintLayoutpour le monde Android: créer une interface utilisateur réactive avec ConstraintLayout

1) dp: (density independent pixels)

Le nombre de pixels représentés dans une unité de dp augmentera à mesure que la résolution d'écran augmente (lorsque vous avez plus de points / pixels par pouce). Inversement sur les appareils avec une résolution inférieure, le nombre de pixels représentés dans l'unité de dp diminuera. Comme il s'agit d'une unité relative, elle doit avoir une base de référence à comparer. Cette ligne de base est un écran de 160 dpi. Voici l'équation:px = dp * (dpi / 160).

2) sp: (scale independent pixels)

Cette unité est mise à l'échelle en fonction du dpi de l'écran (similaire au dp) ainsi que de la préférence de taille de police de l'utilisateur.

3) px: (pixels)

Pixels ou points réels sur l'écran.

Pour plus de détails, vous pouvez visiter

Guide du développeur Android> Guide du développeur Android Dimension
> Écrans

Taille de l' écran dans Android sont regroupées en catégories ldpi, mdpi, hdpi, xhdpi, xxhdpiet xxxhdpi. La densité d'écran est la quantité de pixels dans une zone (comme le pouce) de l'écran. Elle est généralement mesurée en points par pouce ( dpi).

PX(Pixels):

• notre pixel standard habituel qui correspond au pixel de l'écran. pxest destiné aux pixels absolus. Ceci est utilisé si vous souhaitez donner en termes de pixels absolus pour la largeur ou la hauteur. Non recommandé.

DP/DIP(Density pixels / Density independent pixels):

• dip == dp. Dans les versions antérieures d'Android, dip était utilisé et remplacé par la suite dp. C'est une alternative à px.

• En règle générale, nous n'utilisons jamais pxcar c'est une valeur absolue. Si vous utilisez pxpour définir la largeur ou la hauteur, et si cette application est téléchargée sur différents appareils de taille d'écran, cette vue ne s'étirera pas selon la taille d'origine de l'écran.

• dpest fortement recommandé d'utiliser à la place de px. À utiliser dpsi vous souhaitez mentionner la largeur et la hauteur pour agrandir et réduire dynamiquement en fonction des tailles d'écran.

• si nous donnons dp/dip, android calculera automatiquement la taille des pixels sur la base d'un écran de 160 pixels.

SP(Scale independent pixels):

• mis à l'échelle en fonction de la préférence de taille de police de l'utilisateur. Les polices doivent utiliser sp.

• en mentionnant les tailles de police adaptées à différentes tailles d'écran, utilisez sp. Ceci est similaire à dp.Utilisez en spparticulier pour que les tailles de police augmentent et diminuent dynamiquement en fonction des tailles d'écran

La documentation Android indique:

lors de la spécification des dimensions, utilisez toujours l'un dpou l' autre ou les spunités. A dpest un pixel indépendant de la densité qui correspond à la taille physique d'un pixel à 160 dpi. An spest la même unité de base, mais est mis à l'échelle par la taille de texte préférée de l'utilisateur (c'est un pixel indépendant de l'échelle), vous devez donc utiliser cette unité de mesure lors de la définition de la taille du texte

L'écran d'un téléphone mobile est composé de milliers de minuscules points appelés pixels (px) . Un pixel est le plus petit élément qui va faire l'image. Plus le nombre de pixels pour faire une image ou un libellé est élevé, plus il devient net et rend l'écran du smartphone plus lisible.

La résolution d'écran est mesurée en termes de nombre de pixels sur l'écran. La résolution d'écran est une spécification couramment utilisée lors de l'achat d'un appareil, mais elle n'est en fait pas très utile lors de la conception pour Android car la réflexion sur les écrans en termes de pixels ignore la notion de taille physique, qui pour un appareil tactile est vraiment très importante.

Le pixel indépendant de la densité (dp ou dip) permet au concepteur de créer des ressources qui apparaissent de la manière attendue, quelle que soit la résolution ou la densité du périphérique cible.

Un pixel indépendant de la densité (dp ou dip) est égal à un pixel à la densité de base ou 160 dpi (points par pouce).

1 px / 1dp = 160 dpi / 160 dpi

2 px / 1dp = 320 dpi (2x) / 160 dpi

où,

dpi est des points par pouce

Donc, à 320 dpi, 1 dp est égal à 2 px.

Formule

px / dp = dpi / 160 dpi

Les points par pouce (dpi) sont une mesure de la netteté (c'est-à-dire la densité des points éclairés) sur un écran d'affichage. Les points par pouce pour une résolution d'image donnée différeront en fonction de la taille globale de l'écran, car le même nombre de pixels sont répartis sur un espace différent.

Travailler avec des pixels indépendants de la densité nous aide à faire face à une situation comme celle où vous avez deux appareils avec la même résolution en pixels, mais un espace différent. Supposons que dans un cas, une tablette et un téléphone aient la même résolution en pixels 1280 x 800 pixels (160 dpi) et 800 x 1280 pixels (320 dpi) respectivement.

Maintenant, comme une tablette est à la densité de base (160 dpi), ses tailles de pixels physiques et indépendantes de la densité sont les mêmes, 1280 par 800. Le téléphone, d'autre part, a une densité de pixels plus élevée, il a donc la moitié autant de pixels indépendants de la densité que physique pixels. Donc, un téléphone a 400 x 640 pixels indépendants de la densité. Ainsi, l'utilisation d'un pixel indépendant de la densité permet de visualiser mentalement plus facilement que la tablette a beaucoup plus d'espace que le téléphone.

De même, si vous avez deux appareils avec une taille d'écran similaire, mais une densité de pixels différente, disons que l'un est 800 par 1280 pixels (320 dpi), et l'autre est 400 par 640 pixels (160 dpi), nous n'avons pas besoin de définir totalement différentes dispositions pour ces deux appareils, car nous pouvons mesurer les actifs en termes de pixels indépendants de la densité, ce qui est le même pour les deux appareils.

800 x 1280 pixels (320 dpi) = 400 x 640 pixels indépendants de la densité (dp)

400 x 640 pixels (160 dpi) = 400 x 640 pixels indépendants de la densité (dp)

Mettre à l'échelle les pixels indépendants (sp) est l'unité préférée pour la taille de la police. À des fins d'accessibilité, Android permet aux utilisateurs de personnaliser la taille de police de leur appareil. Les utilisateurs qui ont du mal à lire du texte peuvent augmenter la taille de police de leur appareil. Vous pouvez normalement trouver cette option dans les paramètres d'affichage de votre téléphone ou tablette sous la taille de la police. Il est souvent également disponible via les paramètres d'accessibilité.

Avec des pixels indépendants de l'échelle, 16 sp est exactement identique à 16 dp lorsque la taille de police de l'appareil est normale ou 100%. Mais lorsque la taille de police de l'appareil est grande, par exemple 125%, 16 sp se traduira par 20 dp ou 1,25 fois 16.

Si vous utilisez dp comme unité de taille de police, ce morceau de texte a une taille physique spécifique, peu importe si l'utilisateur a personnalisé la taille de police du périphérique. L'utilisation d'unités SP améliorera l'expérience des personnes malvoyantes.

Référence : Udacity , Google

sp: pixel indépendant de l'échelle

Vous devez l'utiliser avec des textes car il est automatiquement mis à l'échelle en fonction de la taille de police utilisée par l'utilisateur dans son appareil.

px: pixel ou élément d'image est le seul point sur l'écran

Densité de pixels

La densité et la résolution des pixels de l'écran varient selon la plate-forme. Les pixels indépendants de l'appareil et les pixels évolutifs sont des unités qui offrent un moyen flexible de s'adapter à une conception sur toutes les plateformes.

Calcul de la densité de pixels

Le nombre de pixels qui s'inscrivent dans un pouce est appelé densité de pixels. Les écrans haute densité ont plus de pixels par pouce que les écrans basse densité ....

Le nombre de pixels qui s'inscrivent dans un pouce est appelé densité de pixels. Les écrans haute densité ont plus de pixels par pouce que ceux à faible densité. Par conséquent, les éléments d'interface utilisateur des mêmes dimensions de pixels apparaissent plus grands sur les écrans à faible densité et plus petits sur les écrans à haute densité.

Pour calculer la densité d'écran, vous pouvez utiliser cette équation:

Densité de l'écran = largeur (ou hauteur) de l'écran en pixels / largeur (ou hauteur) de l'écran en pouces

Indépendance de densité

La densité et la résolution des pixels de l'écran varient selon la plate-forme. Les pixels indépendants de l'appareil et les pixels évolutifs sont des unités qui offrent un moyen flexible de s'adapter à une conception sur toutes les plateformes.

Calcul de la densité de pixels Le nombre de pixels pouvant tenir dans un pouce est appelé densité de pixels . Les écrans haute densité ont plus de pixels par pouce que les écrans basse densité ....

L'indépendance de densité se réfère à l'affichage uniforme des éléments d'interface utilisateur sur des écrans de densités différentes.

Les pixels indépendants de la densité , écrits en dp (prononcés « creux »), sont des unités flexibles qui évoluent pour avoir des dimensions uniformes sur n'importe quel écran. Les interfaces utilisateur matérielles utilisent des pixels indépendants de la densité pour afficher les éléments de manière cohérente sur des écrans de densités différentes.

1. Écran basse densité affiché avec indépendance de densité
2. Écran haute densité affiché avec indépendance de densité

Lire le texte intégral https://material.io/design/layout/pixel-density.html

Pixels (px) - correspond aux pixels réels sur l'écran. Ceci est utilisé si vous souhaitez donner en termes de pixels absolus pour la largeur ou la hauteur.

Pixels indépendants de la densité (dp ou dip) - unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi, donc un dp est un pixel sur un écran de 160 dpi. Le rapport dp / pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. Remarque: Le compilateur accepte à la fois "dip" et "dp", bien que "dp" soit plus cohérent avec "sp".

Pixels indépendants de l'échelle (sp) - c'est comme l'unité dp, mais elle est également mise à l'échelle par la préférence de taille de police de l'utilisateur. Il est recommandé d'utiliser cet appareil lors de la spécification des tailles de police, afin qu'elles soient ajustées à la fois pour la densité de l'écran et les préférences de l'utilisateur.

Utilisez toujours dp et sp uniquement. sp pour les tailles de police et dp pour tout le reste. Il rendra l'interface utilisateur compatible pour les appareils Android avec des densités différentes. Vous pouvez en savoir plus sur le pixel et le dp sur https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-independent-pixels-dp-

URL de la source: - http://www.androidtutorialshub.com/what-is-the-difference-between-px-dp-dip-sp-on-android/

Je veux fournir un moyen simple de comprendre dp. En fait, je pense que dpc'est le plus facile à comprendre. dpest juste une unité de longueur physique. C'est de la même dimension que mmou inch. C'est juste pratique pour nous d'écrire 50dp, 60dpplutôt que 50/160 inchou 60/160 inch, car on dpest juste 1/160 inchquelle que soit la taille d'écran ou la résolution.

Le seul problème est que les ppp android de certains écrans ne sont pas précis. Par exemple, un écran classé à 160 dpi peut avoir 170 dpi en effet. Le résultat du calcul dpest donc flou. Il devrait être approximativement le même que 1/160 inch.