Quelle est la difference entre "px", "dip", "dp" et "sp"?

Question

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

• px
• tremper
• dp
• sp

Answer 1

Depuis le Android Developer Documentation :

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

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

3. mm
   Millimètres - en fonction de 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
   Densité - pixels indépendants - unité abstraite basée sur la densité physique de l'écran. Ces unités étant relatives à un écran de 160 dpi, un dp correspond à un pixel sur un écran de 160 dpi. Le rapport dp sur pixel changera avec la densité de l'écran, mais pas nécessairement proportionnellement. Remarque: le compilateur accepte à la fois "dip" et "dp", bien que "dp" soit plus compatible avec "sp".

6. sp
   Échelle - pixels indépendants - il s’agit de l’unité dp, mais il est également mis à l’échelle par les préférences de taille de police de l’utilisateur. Il est recommandé d’utiliser cet appareil lors de la définition des tailles de police afin qu’elles soient ajustées en fonction de la densité de l’écran et des 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      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Plus d'informations peuvent également être trouvées dans le documentation Google Design .

Answer 2

Vous trouverez ici une description détaillée de tout ce qui a trait à cela et à la meilleure prise en charge de plusieurs écrans de tailles et de densités différentes:

• Prise en charge de plusieurs écrans

Taille de l'écran
Taille physique réelle, mesurée en diagonale de l'écran. Par souci 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é de l'écran
Le nombre de pixels dans une zone physique de l'écran; généralement appelé dpi (points par pouce). Par exemple, un écran de densité "basse" a moins de pixels dans une zone physique donnée, par rapport à un écran de densité "normale" ou "haute". 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, très haute, très très haute et très très très haute.

Orientation
L'orientation de l'écran du point de vue de l'utilisateur. Il s’agit d’un paysage ou d’un portrait, ce qui signifie que le format de l’écran est large ou grand. Sachez que non seulement différents périphériques fonctionnent par défaut dans différentes orientations, mais que l'orientation peut changer au moment de l'exécution lorsque l'utilisateur fait pivoter le périphérique.

Résolution
Le 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 doivent concerner que 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 virtuelle à utiliser lors de la définition de la présentation de l'interface utilisateur, pour exprimer les dimensions ou la position de la présentation de manière indépendante de la densité. Le pixel indépendant de la densité équivaut à un pixel physique sur un écran de 160 dpi, soit la densité de base supposée par le système pour un écran de 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, 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 de 240 dpi, 1 dp équivaut à 1,5 pixel physique. Vous devez toujours utiliser les unités dp lors de la définition de l'interface utilisateur de votre application afin de garantir un affichage correct de votre interface utilisateur sur des écrans de densités différentes.

Si vous souhaitez vraiment développer une application Android pour plusieurs types d'appareils, vous devez avoir lu le document de développement de la prise en charge des écrans au moins une fois. En plus de cela, il est toujours bon de connaître le nombre réel de périphériques actifs ayant une configuration d'écran particulière.

• tailles et densités d'écran

Answer 3

Je vais expliquer plus en détail comment dp convertit au format px:

• Si vous utilisez un périphérique mdpi, une image 150 x 150 px prendra 150 * 150 dp d’espace d’écran.
• Si vous utilisez un périphérique hdpi, une image 150 x 150 px prendra 100 * 100 dp d’espace d’écran.
• Si vous utilisez un périphérique xhdpi, une image 150x150 px prendra 75 * 75 dp d’espace d’écran.

Inversement: vous voulez ajouter une image à votre application et en avoir besoin pour remplir un contrôle 100 * 100 dp. Vous devrez créer des images de différentes tailles 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

Answer 4

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

en pouces - basé sur la taille physique de l'écran.

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

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

Dp Density - Pixels indépendants - unité abstraite basée sur la densité physique de l'écran. Ces unités étant relatives à un écran de 160 dpi, un dp correspond à un pixel sur un écran de 160 dpi. Le rapport dp sur pixel changera avec la densité de l'écran, mais pas nécessairement proportionnellement. Remarque: le compilateur accepte à la fois dip et dp, bien que dp soit plus cohérent avec sp.

pixel indépendant de l'échelle - cela ressemble à l'unité dp, mais elle est également mise à l'échelle en fonction de la préférence de taille de police de l'utilisateur. Il est recommandé d’utiliser cet appareil lors de la définition des tailles de police afin qu’elles soient ajustées en fonction de la densité de l’écran et des préférences de l’utilisateur.

Prenons l'exemple de deux écrans de même taille mais dont l'un a une densité d'écran de 160 dpi (points par pouce, c'est-à-dire pixels par pouce) et l'autre 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

Answer 5

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. Par souci 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é de l'écran:

La quantité de pixels dans une zone physique de l'écran; généralement appelé dpi (points par pouce). Par exemple, un écran de densité "basse" a moins de pixels dans une zone physique donnée, par rapport à un écran de densité "normale" ou "haute". Par souci 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 très élevée.

Orientation:

L'orientation de l'écran du point de vue de l'utilisateur. Il s’agit d’un paysage ou d’un portrait, ce qui signifie que le format de l’écran est large ou grand. Sachez que non seulement différents périphériques fonctionnent par défaut dans différentes orientations, mais que l'orientation peut changer au moment de l'exécution lorsque l'utilisateur fait pivoter le périphérique.

Résolution:

Le 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 doivent concerner que 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 virtuelle à 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 de 160 dpi, soit la densité de base supposée par le système pour un écran de 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, 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 de 240 dpi, 1 dp équivaut à 1,5 pixel physique. Vous devez toujours utiliser les unités dp lors de la définition de l'interface utilisateur de votre application afin de garantir un affichage correct de votre interface utilisateur sur des écrans de densités différentes.

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

Answer 6

dp est dip. Utilisez-le pour tout (marge, remplissage, etc.).

Utilisez sp pour {taille du texte} uniquement.

---

Pour obtenir la même taille sur différentes densités d'écran, Android convertit ces unités en pixels lors de l'exécution, évitant ainsi des calculs compliqués.

---

Voyez la différence entre px, dp et sp sur différentes tailles d'écran.

Source: Programmation Android: Le Guide du Big Nerd Ranch

Answer 7

J'ai calculé la formule ci-dessous pour effectuer les conversions dpi en dp et sp

Answer 8

Définitions

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

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) ~ 120dpi
• mdpi (moyenne) ~ 160dpi
• hdpi (élevé) ~ 240 ppp
  • la plupart des appareils en 2015 sont ici
• xhdpi (très haute) ~ 320 dpi
  • Apple iPhone 4/5/6, Nexus 4
• xxhdpi (extra-extra-high) ~ 480dpi
  • Nexus 5
• xxxhdpi (extra-extra-extra-high) ~ 640 dpi

dip ou dp sont indépendants de la densité pixels , 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 une échelle pixel indépendant . Ils sont mis à l’échelle lorsque l’option Texte large est activée dans Settings > Accessibility

• 1sp = 1dp
• 1sp = 1.2dp avec accessibilité Texte large

Quoi utiliser?

Utilisez sp pour la taille du texte.

Utilisez dp pour tout le reste.

Answer 9

Source 1

Source 2

Source : (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é supérieure, le nombre de pixels utilisés pour dessiner 1dp est augmenté d'un facteur approprié pour la résolution 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 sur pixel changera avec la densité de l'écran, mais pas nécessairement proportionnellement. 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 périphériques.

sp

Pixels indépendants de l'échelle - Cela ressemble à l'unité dp, mais il est également mis à l'échelle en fonction de la préférence de taille de police de l'utilisateur. Il est recommandé d'utiliser cette unité 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 à l'écran. Cette unité de mesure n'est pas recommandée car la représentation réelle peut varier d'un périphérique à l'autre. chaque périphérique peut avoir un nombre différent de pixels par pouce et peut avoir plus ou moins de pixels totaux disponibles à 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 (et non du nom du fichier XML). En tant que tel, vous pouvez combiner des ressources de dimension avec d'autres ressources simples dans le même fichier XML, sous un seul élément.

Answer 10

Fondamentalement, le seul moment où px s'applique est d'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 est arrondi à 0.

Answer 11

px

Pixels - correspond aux pixels réels à 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 étant relatives à un écran de 160 dpi, un dp correspond à un pixel sur un écran de 160 dpi.

Utilisation de dp:

Indépendance de la densité - Votre application obtient une "indépendance de la densité" lorsqu'elle préserve la taille physique (du point de vue de l'utilisateur) des éléments de l'interface utilisateur lorsqu'elle est affichée sur des écrans. avec des densités différentes. (c.-à-d.) L’image devrait avoir la même taille (pas d’agrandissement ni de réduction) dans différents types d’écrans.

sp

Pixels indépendants de l'échelle - cela ressemble à l'unité dp, mais il est également réduit en fonction de la préférence de taille de police de l'utilisateur.

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

Answer 12

Où utiliser quoi & relation entre px & dp?

Pixel indépendant de la densité (dp)

Unité de pixel virtuelle à 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é. Comme décrit ci-dessus, le pixel indépendant de la densité est équivalent à un pixel physique sur un écran de 160 dpi, qui est la densité de base supposée par le système pour un écran de 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, 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 de 240 dpi, 1 dp équivaut à 1,5 pixel physique. Vous devez toujours utiliser les unités dp lors de la définition de l'interface utilisateur de votre application afin de garantir un affichage correct de votre interface utilisateur sur des écrans de densités différentes.

Comprendre le pixel en dp et inversement est essentiel (en particulier pour donner des valeurs de dp exactes à l'équipe de création)

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 de création. Sinon, la perte de précision se produira en multipliant par 0.5.

px

C'est expliqué ci-dessus. Essayez d'éviter dans les fichiers de mise en page. Mais il existe certains cas, où px est requis. par exemple, la ligne de séparation ListView. px est préférable ici pour donner une ligne d'un pixel comme diviseur 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 en même temps que la taille des polices du périphérique (c'est-à-dire Affichage -> Polices sur le périphérique). Si vous souhaitez conserver une police de taille statique dans l'application, vous pouvez indiquer la dimension de la police dans dp. Dans un tel cas, cela ne changera jamais. Les développeurs peuvent obtenir une telle exigence pour certains écrans spécifiques. Pour cela, ils peuvent utiliser dp au lieu de sp. Dans tous les autres cas, sp est recommandé.

Answer 13

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

Answer 14

Tout ce qui concerne la taille et l'apparence du texte doit utiliser sp ou pt. Tandis que tout ce qui concerne la taille des commandes, les dispositions, etc. doit être utilisé avec dp.

Vous pouvez utiliser à la fois dp et dip à ses emplacements.

Answer 15

Je voudrais seulement utiliser dp.

On parle beaucoup d'utiliser "sp" pour les tailles de police, et bien que j'apprécie ce point, je ne pense pas que ce soit la bonne chose à faire du point de vue de la conception. Vous pouvez finir par casser votre conception si l'utilisateur a une sélection de taille de police arrétée, et l'utilisateur finira par blâmer l'application, et non par ses propres choix de vie.

De plus, si vous utilisez une application sp-fonte sur une tablette 160 dpi, vous constaterez que tout augmente ... mais votre police, qui va paraître minuscule en comparaison. Ce n'est pas un bon coup d'oeil.

Bien que l’idée des polices "sp" ait bon coeur, c’est une mauvaise idée. Stick avec dp pour tout.

Answer 16

sp = pixel indépendant de l'échelle

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

dpi = points par pouce

Nous devrions éviter d'utiliser sp.

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

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

• ldpi (bas) ~ 120 dpi
• mdpi (moyen) ~ 160 dpi
• hdpi (haut) ~ 240 dpi
• xhdpi (très haut) ~ 320 dpi
• xxhdpi (extra-extra-high) ~ 480 dpi
• xxxhdpi (extra-extra-extra-high) ~ 640 dpi

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

Même chose 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 du périphérique 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 tout périphérique:

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

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

Answer 17

Différence entre dp et sp unités mentionnées en tant que " préférence de taille de police par l'utilisateur " par les réponses copiées de la documentation officielle sont visibles au moment de l'exécution en modifiant l'option Settings->Accessibility->Large Text.

L'option Large Text force le texte à devenir 1.3 fois plus gros.

private static final float LARGE_FONT_SCALE = 1.3f;

Cela pourrait bien sûr dépendre du fournisseur, car il réside dans packages/apps/Settings .

Answer 18

dpi -

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

px - pixel

• Pour cartographier les pixels de l'écran

pt - points

• Environ 1/72 de pouce, en ce qui concerne la taille de l'écran physique.

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

mm-millimètre - en ce qui concerne la taille de l'é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'.

trempette -

• dip == dp
• Pixel indépendant de la densité.
• Cela varie en fonction de la densité de l'écran.
• En écran 160 dpi, 1 dp = 1 pixel.
• Utilisez dp sauf la taille de la police.

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

Formule de conversion d'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  

Answer 19

La taille de l'écran dans Android est regroupée dans les catégories small, medium, large, extra large, double-extra et triple-extra. La densité de l'écran est la quantité de pixels dans une zone (telle que pouces) de l'écran. Généralement, il est mesuré en points par pouce (dpi). La densité de l'écran est regroupée en faible, moyenne, élevée et très élevée. La résolution est le nombre total de pixels à l'écran.

• dp: Pixel indépendant de la densité, il varie en fonction de la densité de l'écran. En écran 160 dpi, 1 dp = 1 pixel. Sauf pour la taille de la police, utilisez toujours dp.
• dip: dip == dp. Dans les versions antérieures de Android, dip était utilisé puis remplacé par dp.
• sp: Échelle du pixel indépendant, mise à l'échelle en fonction des préférences 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 de l'écran physique.
• mm: millimètres, par rapport à la taille de l'écran physique.
• pt: 1/72 de pouce, en ce qui concerne la taille de l'écran physique.

Formule de conversion entre unités

 px = dp * (dpi / 160)

dp en px dans le périphérique

Les exemples suivants peuvent aider à mieux comprendre. La mise à l'échelle s'effectue en fonction d'une taille de 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 écran en mdpi
• 100 dp x 100 dp d'espace écran en hdpi
• 75 dp x 75 dp d'espace écran en xhdpi

Vous pouvez utiliser la calculatrice DPI suivante pour corriger la taille de vos images et d’autres dimensions lorsque vous souhaitez obtenir une conception d’interface utilisateur uniforme dans 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);        
   }
}

Pour plus d'informations, reportez-vous au lien suivant.

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

Answer 20

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

Il définit les constantes "DENSITY_ *".

• ldpi (faible) ~ 120dpi
• mdpi (moyenne) ~ 160dpi
• hdpi (haute) ~ 240dpi
• xhdpi (très haut) ~ 320dpi
• xxhdpi (extra-extra-high) ~ 480dpi
• xxxhdpi (extra-extra-extra-high) ~ 640 dpi

Tiré de ici .

Cela dissipera beaucoup de confusion lors de la traduction entre px et dp, si vous connaissez votre résolution d'écran.

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

px = 60 * (240 / 160)

Answer 21

• 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, alors que dip est utilisé (également appelé dp) pour les autres.

Answer 22

Veuillez lire la réponse du wiki de la communauté. Ci-dessous sont mentionnées quelques informations à prendre en compte en plus des réponses ci-dessus.

sp = pixel indépendant de l'échelle

dp = pixels indépendants de la densité

dpi = pixels de densité

J'ai parcouru les réponses ci-dessus ... ne les trouvant pas tout à fait correctes. sp pour la taille du texte, dp pour les limites de la mise en page - standard. Mais sp pour la taille du texte brisera la mise en page si elle est utilisée sans précaution dans la plupart des périphériques.

sp prend la taille du texte de l’appareil, alors que dp utilise celle du standard de densité de l’appareil (ne changez jamais l’appareil) Disons que le texte de 100sp peut occuper 80% de l’écran ou 100% de l’écran en fonction de la taille de la police définie dans l’appareil

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

Utilisez sp et dp pour la taille du texte en considérant UX.

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

Certaines personnes utilisent une taille FONT énorme dans leur téléphone pour une plus grande lisibilité. Leur donner un petit texte de taille codée en dur constituera un problème UX. Mettez sp pour le texte si nécessaire, mais assurez-vous qu'il ne casse pas la mise en page.

De même, si vous avez une seule application prenant en charge toutes les dimensions, l'ajout d'éléments xxxhdpi augmente considérablement la taille de l'application. Mais maintenant, les téléphones xxxhdpi sont courants et nous devons donc inclure au moins les ressources 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 personnes utilisent des polices personnalisées sur leur téléphone. Donc, le manque de police peut causer des problèmes d'espacement et tout. Dites 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éveloppement Google pour obtenir des informations sur la densité et la densité de base pour Android. https://developer.Android.com/training/multiscreen/screendensities

Answer 23

Je suis tombé sur un bon article sur la conception de l'interface de l'application Android pour différentes résolutions d'écran, et j'aimerais le laisser ici uniquement pour les personnes cherchant dans cette zone. Oui, je sais que c'est en quelque sorte décrit dans Google Docs (et mentionné dans les posts ci-dessus), j'ai lu cela, mais ce n'était pas bon pour moi (ouais, je suis peut-être trop stupide)). Je ne savais toujours pas comment concevoir des modèles capables de gérer différentes tailles d'écran. Je déteste le concept de DP, etc., lorsque je dois implémenter une interface utilisateur "flexible" pour différents écrans. (Hey développeurs iOS - oui, vous avez raison, c’est le concept Storyboard).

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

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

Blog JMSTUDIO: - Décider Android Taille de l'écran de l'application

Comment concevoir une interface utilisateur pour Android Des applications 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 un guide de taille d'écran Android. Lorsque nous obtenons la taille d'é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 faciliter les calculs, 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 un périphérique LDPI, la taille des images de densité de repos sera de 48 × 48 pour le format MPPI, de 72 × 72 pour le format HDPI et de 96 × 96 pour le format xhdpi.

Comment concevoir Android Interface utilisateur de Apps dans Photoshop

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

Selon la définition d’Android, 1pd est égal à 1px avec un périphérique de 160 dpi (mdpi). Nous voulons donc concevoir une application Android pour xlarge Android avec une densité mdpi. Nous pouvons définir la taille de notre interface utilisateur en pixels de 960 pixels en largeur et de 720px en 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 intéressé par une interface utilisateur "flexible", consultez cette bibliothèque: n Android SDK qui fournit une nouvelle unité de taille - sdp (scalable dp). Cette unité de taille est adaptée à la taille de l'écran (ceci est également mentionné dans une réponse ici, à propos de SDP librairie)

ADDED2 Google a enfin compris l'utilité du concept d'interface utilisateur iOS Storeboard, et voici ConstraintLayout pour Android monde: - Construire une interface utilisateur réactive avec ConstraintLayout

Answer 24

1) dp: (density independent pixels)

Le nombre de pixels représentés dans une unité de dp augmentera à mesure que la résolution de l'é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. Puisqu'il s'agit d'une unité relative, il doit être comparé à une ligne de base. Cette référence est un écran de 160 dpi. Voici l'équation: px = dp * (dpi / 160).

2) sp: (scale independent pixels)

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

3) px: (pixels)

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

Pour plus de détails, vous pouvez visiter

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

Answer 25

Taille de l'écran dans Android est regroupé dans les catégories ldpi, mdpi, hdpi, xhdpi, xxhdpi et xxxhdpi. Densité de l'écran est la quantité de pixels dans une zone (telle que pouces) de l'écran. Généralement, il est mesuré en points par pouce (dpi).

PX(Pixels):

• notre pixel standard habituel qui correspond au pixel de l'écran. px est destiné aux pixels absolus. Ceci est utilisé si vous voulez donner des pixels absolus en largeur ou en hauteur. Non recommandé.

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

• dip == dp. Dans les versions antérieures de Android, dip était utilisé et ultérieurement remplacé par dp. C'est une alternative de px.

• Généralement, nous n'utilisons jamais px car c'est une valeur absolue. Si vous utilisez px pour définir la largeur ou la hauteur, et si cette application est en cours de téléchargement sur des périphériques de tailles d'écran différentes, l'affichage ne sera pas étiré selon la taille d'origine de l'écran.

• Il est vivement recommandé d'utiliser dp à la place de px. Utilisez dp si vous souhaitez mentionner largeur et hauteur pour agrandir et réduire de manière dynamique en fonction de la taille de l'écran.

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

SP(Scale independent pixels):

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

• lorsque vous indiquez que la taille des polices doit correspondre à différentes tailles d'écran, utilisez sp. Ceci est similaire à dp. Utilisez sp, en particulier pour les tailles de police, afin de croître et de se réduire de manière dynamique en fonction de la taille de l'écran.

La documentation Android dit:

lorsque vous spécifiez des dimensions, utilisez toujours les unités dp ou sp. Un dp est un pixel indépendant de la densité qui correspond à la taille physique d'un pixel à 160 dpi. Un sp correspond à la même unité de base, mais est redimensionné en fonction de la taille de texte souhaitée par l'utilisateur (il s'agit d'un pixel indépendant de l'échelle). Vous devez donc utiliser cette unité de mesure pour définir la taille du texte.

Answer 26

L'écran d'un téléphone mobile est composé de milliers de points minuscules appelés pixels (px) . Un pixel est le plus petit élément qui va faire l’image. Plus le nombre de pixels nécessaires à la création d’une image ou d’un libellé est élevé, plus elle est nette et plus lisible pour l’écran du smartphone.

La résolution de l'écran est mesurée en termes de nombre de pixels à 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 le fait de considérer les écrans en termes de pixels ne tient pas compte de la notion de taille physique, qui est un élément tactile. vraiment vraiment important.

Les pixels indépendants de la densité (dp ou dip) permettent au concepteur de créer des actifs qui apparaissent de manière attendue, quelles que soient 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 en points par pouce

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

Formule

px/dp = dpi/160dpi

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

Travailler avec des pixels indépendants de la densité nous aide à gérer une situation semblable à celle où vous avez deux périphériques avec la même résolution en pixels, mais avec une quantité d'espace différente. Supposons que dans un cas, une tablette et un téléphone ont respectivement la même résolution en pixels de 1280 x 800 pixels (160 dpi) et de 800 x 1280 pixels (320 dpi).

Maintenant, parce qu’une tablette est à la densité de base (160 dpi), sa taille en pixels physiques et indépendants de la densité est la même, soit 1280 x 800 pixels. Par contre, le téléphone a une densité de pixels plus élevée; il a donc la moitié moins de pixels indépendants de la densité que de pixels physiques. pixels. Ainsi, un téléphone a 400 pixels sur 640 pixels indépendants de la densité. En utilisant un pixel indépendant de la densité, il est donc plus facile d’imaginer mentalement 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 mesure 800 x 1280 pixels (320 dpi) et l'autre 400 x 640 pixels (160 dpi), il n'est pas nécessaire de définir totalement. différentes dispositions pour ces deux appareils, car nous pouvons mesurer les actifs en termes de pixel indépendant de la densité, identique pour les deux appareils.

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

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

Les pixels indépendants de l'échelle (sp) constituent 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 la police de leur appareil. Les utilisateurs qui ont des difficultés à lire du texte peuvent augmenter la taille de la police de leur appareil. Vous pouvez normalement trouver cette option dans les paramètres d'affichage de votre téléphone ou de votre 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 pixels est exactement le même que 16 pixels lorsque la taille de police du périphérique est normale ou égale à 100%. Mais lorsque la taille de la police du périphérique est importante, par exemple 125%, 16 ps signifie 20 dp ou 1,25 fois 16.

Si vous utilisez dp comme unité pour la taille de la police, ce texte a une taille physique spécifique, que l'utilisateur ait ou non personnalisé la taille de la police du périphérique. L'utilisation d'unités sp sera une meilleure expérience pour les personnes malvoyantes.

Référence : dacity , Google

Answer 27

sp: pixel indépendant de l'échelle

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

px: pixel ou élément d'image est le point unique à l'écran

Answer 28

Avant de répondre à cette question, laissez-moi d'abord réduire le nombre d'unités. Alors voilà: dp ou dip sont identiques et sont connus sous le nom de pixels indépendants de la densité .

1. px - représente les pixels. Les pixels sont un seul point, un point sur un écran. Généralement, dans l'industrie mobile, il est mesuré en ppp (pixels par pouce). La résolution de l'écran est directement proportionnelle à la ppp. Plus le nombre de pixels par pouce est élevé, plus la résolution de l'écran est élevée.

Par exemple, si vous dessinez une image de taille 200 px * 200 px , son apparence doit être différente en hauteur. multi-résolution par rapport à un périphérique basse résolution. La raison en est qu'une image 200 px sur un téléphone basse résolution sera plus grande que sur un périphérique haute résolution.

Les images ci-dessous montrent une résolution de la même image sur différents téléphones -

• Téléphone avec une résolution d'écran élevée

  

• Téléphone avec une faible résolution d'écran

  

2. dip ou dp - unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran à 160 dpi, ainsi un dp correspond à un pixel sur un écran à 160 dpi. Le rapport dp sur pixel changera avec la densité de l'écran, mais pas nécessairement proportionnellement. "Indépendance de la densité" fait référence à l'affichage uniforme d'éléments de l'interface utilisateur sur des écrans de densités différentes.

• Image qui montre 80px (image de gauche) et 80 dp (image de droite) . Différence de caisse.

Un dp est égal à un pixel physique sur un écran avec une densité de 160 . Pour calculer dp:

dp = (largeur en pixels * 160)/densité de l'écran

3. sp - signifie pixels évolutifs. Généralement sp est utilisé pour les textes sur l'interface utilisateur et sp conserve les paramètres de police. Par exemple, si un utilisateur a sélectionné une police plus grande que 30 sp , la mise à l’échelle automatique apparaîtra grande selon les préférences de l’utilisateur.

Answer 29

SDP - une unité de taille évolutive - il ne s'agit pas fondamentalement d'une unité, mais de ressources de dimension pour des tailles d'écran différentes.

Essayez la bibliothèque sdp de Intuit. C'est très pratique pour résoudre les problèmes d'unité, et vous pouvez supporter rapidement plusieurs écrans .

Usage

Android:paddingBottom="@dimen/_15sdp" pour positif et Android:layout_marginTop="@dimen/_minus10sdp" pour négatif sdp sdp

Il a une valeur équivalente en dp pour chaque taille dans les dossiers values-sw<N>dp (sw = smallestWidth).

Attention

Utilisez-le avec précaution! Dans la plupart des cas, vous devez encore concevoir une mise en page différente pour les tablettes.

Exemple

<LinearLayout
          Android:layout_width="wrap_content"
          Android:layout_height="wrap_content"
          Android:layout_marginTop="@dimen/_minus10sdp"
          Android:paddingBottom="@dimen/_15sdp"
          Android:orientation="horizontal" >

                <TextView
                    Android:layout_width="wrap_content"
                    Android:layout_height="wrap_content"
                    Android:includeFontPadding="false"
                    Android:text="♡"
                    Android:textColor="#ED6C27"
                    Android:textSize="@dimen/_70sdp"
                    Android:textStyle="bold" />

                <TextView
                    Android:layout_width="wrap_content"
                    Android:layout_height="wrap_content"
                    Android:includeFontPadding="false"
                    Android:text="U"
                    Android:textColor="@Android:color/black"
                    Android:textSize="@dimen/_70sdp" />
            </LinearLayout>

Vous pouvez utiliser db pour la taille du texte, mais je préfère ssp pour la taille du texte.

Pour plus de détails, consultez la page de la bibliothèque GitHub .

Answer 30

Je veux fournir un moyen facile de comprendre dp. En fait, je pense que dp est la plus facile à comprendre. dp est simplement une unité de longueur physique. Il a la même dimension que mm ou inch. C'est pratique pour nous d'écrire 50dp, 60dp plutôt que 50/160 inch ou 60/160 inch, car une dp n'est que 1/160 inch quelle que soit la taille de l'écran ou la résolution est.

Le seul problème est que le Android dpi de certains écrans n'est pas précis. Par exemple, un écran classé à 160 dpi peut avoir une résolution de 170 dpi. Le résultat de calcul de dp est donc flou. Il devrait être approximativement identique à 1/160 inch.

Answer 31

Ici aussi existe SDP.

SDP - une unité de taille évolutive

Un SDK Android qui fournit une nouvelle unité de taille - sdp (dp évolutif). Cette unité de taille est adaptée à la taille de l'écran. Il peut aider les développeurs Android à prendre en charge plusieurs écrans.

Pour les vues de texte, veuillez vous référer à ssp qui est basé sur l'unité de taille sp des textes.

Attention!

Utilisez-le avec précaution! Par exemple, dans la plupart des cas, vous devez encore concevoir une mise en page différente pour les tablettes.

Answer 32

Pixels (px) - correspond aux pixels réels à l'écran. Ceci est utilisé si vous voulez donner des pixels absolus en largeur ou en hauteur.

Pixels indépendants de la densité (dp ou dip) - unité abstraite basée sur la densité physique de l'écran. Ces unités étant relatives à un écran de 160 dpi, un dp correspond à un pixel sur un écran de 160 dpi. Le rapport dp sur pixel changera avec la densité de l'écran, mais pas nécessairement proportionnellement. Remarque: le compilateur accepte à la fois “dip” et “dp”, bien que “dp” soit plus compatible avec “sp”.

Pixels indépendants de l’échelle (sp) - cela ressemble à l’unité dp, mais elle est également mise à l’échelle par les préférences de taille de police de l’utilisateur. Il est recommandé d’utiliser cet appareil lors de la définition des tailles de police. Elles seront donc ajustées en fonction de la densité de l’écran et des préférences de l’utilisateur.

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

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

Answer 33

Densité de pixels

La densité et la résolution des pixels de l'écran varient selon la plate-forme. Les pixels indépendants du périphérique et les pixels évolutifs sont des unités offrant un moyen flexible d’adapter une conception sur plusieurs plates-formes.

Calcul de la densité de pixels

Le nombre de pixels qui entrent dans un pouce est appelé densité de pixels. Les écrans haute densité ont plus de pixels par pouce que ceux de faible densité ....

Le nombre de pixels qui entrent 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 de mêmes dimensions en pixels apparaissent plus grands sur les écrans à faible densité et plus petits sur les écrans à haute densité.

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

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

Indépendance de la densité

La densité et la résolution des pixels de l'écran varient selon la plate-forme. Les pixels indépendants du périphérique et les pixels évolutifs sont des unités offrant un moyen flexible d’adapter une conception sur plusieurs plates-formes.

Calcul de la densité de pixels Le nombre de pixels qui entrent dans un pouce est appelé densité de pixels. Les écrans haute densité ont plus de pixels par pouce que ceux de faible densité ....

L’indépendance de densité fait référence à l’affichage uniforme des éléments de l’UI sur des écrans de densités différentes.

Pixels indépendants de la densité, écrits comme dp (prononcé “dips”), sont des unités flexibles dont l’échelle permet d’obtenir des dimensions uniformes sur tout écran. Les interfaces 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 la densité
2. Écran haute densité affiché avec indépendance de la densité

Read full text ​​ https://material.io/design/layout/pixel-density.html

Answer 34

Le rapport dp-pixel changera avec la densité de l'écran, mais pas nécessairement proportionnellement.

Note: Le compilateur accepte à la fois "dip" et "dp", bien que "dp" soit plus compatible avec "sp".

pixels indépendants de l'échelle - cela ressemble à l'unité dp, mais il est également mis à l'échelle en fonction des préférences de taille de police de l'utilisateur.

Answer 35

Android SP vs DP

D'abord, qu'est-ce qu'ils représentent?

sp signifie scale-independent pixels.

dp or dip (utilisez dp dans votre code si vous êtes cool) représente les pixels indépendants de la densité.

Quelle est la différence entre les deux?

Aucun!

Ils ont tous les deux 160 unités par pouce carré, ils sont indépendants de la densité et n’ont pas la même taille physique sur des écrans différents.

Alors, quand devriez-vous utiliser sp et quand vous devriez utiliser dp?

Utilisez sp pour taille du texte… car il est mis à l'échelle en fonction de la préférence de taille de police de l'utilisateur.

Utilisez dp pour tout le reste.