Quelle est la différence entre « px », « dip », « dp » et « sp »?
https://stackoverflow.com/questions/2025282
-
19-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Quelle est la différence entre les unités de mesure Android?
- px
- dip
- dp
- sp
La solution
De Developer Documentation Android :
-
px Pixels -. Correspond à des pixels réels sur l'écran
-
pouces -. en fonction de la taille physique de l'écran
1 pouce = 2,54 cm -
mm Millimètres -. En fonction de la taille physique de l'écran
-
pt Points -. 1/72 de pouce en fonction de la taille physique de l'écran
-
dp ou dip Densité -indépendante Pixels - une unité abstraite qui est basée sur la densité physique de l'écran. Ces unités sont par rapport à un 160 dpi écran, donc une dp est un pixel sur un écran de 160 dpi. Le rapport de dp-à-pixel va changer 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" est plus compatible avec "sp".
-
sp échelle -indépendante Pixels - c'est comme l'unité dp, mais il est également mis à l'échelle par la préférence de taille de la police de l'utilisateur. Il vous est recommandé utiliser cet appareil lors de la spécification des tailles de police, ils seront ajustés à la fois la densité de l'écran et les préférences de l'utilisateur.
De Indépendance Comprendre 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 être trouve aussi dans le Google Conception Documentation .
Autres conseils
Un peu de tout cela et comment obtenir le meilleur support pour de multiples écrans de différentes tailles et densités est très bien documenté ici:
Taille de l'écran taille réelle, mesurée en diagonale de l'écran. Pour simplifier, les groupes Android tout l'écran en quatre tailles réelles tailles généralisées:. petites, normales, grandes et extra-large
Trames Le nombre de pixels dans une zone physique du écran; habituellement dénommée dpi (points par pouce). Par exemple, un écran de densité « faible » a moins de pixels dans une zone physique donnée, par rapport à un écran de masse volumique « normale » ou « élevé ». Pour la simplicité, groupes Android toutes les densités d'écran réelles en six généralisés densités: faible, moyenne, haute, très haute, extra-extra-haute, et extra-extra-extra-haute.
Orientation L'orientation de l'écran du point de l'utilisateur vue. C'est portrait ou paysage, ce qui signifie que de l'écran rapport d'aspect est soit large ou haut, respectivement. Soyez conscient que seulement différents dispositifs fonctionnent dans des orientations différentes par par défaut, mais l'orientation peut changer lors de l'exécution lorsque l'utilisateur fait tourner le dispositif.
Résolution Le nombre total de pixels physiques sur un écran. Lors de l'ajout du support pour de multiples écrans, les applications ne travaille pas directement avec la résolution; les applications devraient être concernés uniquement avec la taille de l'écran et de la densité, comme indiqué par la généralisation groupes de taille et de densité.
pixel de densité indépendant (dp) A virtuelle unité de pixel que vous devez utiliser lors de la définition mise en page l'interface utilisateur, d'exprimer dimensions mise en page ou la position d'une manière indépendante de la densité. Le pixel de densité indépendant est équivalent à un pixel physique sur un 160 dpi écran, qui est la densité de référence pris en charge par le système pour une écran de densité « moyenne ». Lors de l'exécution, le système traite de manière transparente mise à l'échelle des unités dp, au besoin, en fonction de la densité réelle de l'écran en cours d'utilisation. La conversion des unités de dp de pixels de l'écran est Facile:
px = dp * (dpi / 160). Par exemple, sur un écran 240 dpi, 1 dp est égal à 1,5 pixels physiques. Vous devriez toujours utiliser des unités lorsque dp la définition de l'interface utilisateur de votre application, afin de garantir un affichage correct de l'interface utilisateur sur écrans avec des densités différentes.
Si vous êtes sérieux au sujet de tout le développement d'une application Android pour plus d'un type d'appareil, vous devez avoir lu les écrans document de développement de support au moins une fois. En plus de cela, il est toujours une bonne chose de connaître le nombre réel de dispositifs actifs qui ont une configuration d'écran particulier.
- les tailles d'écran et Densités
Je vais parler plus en détail comment exactement dp convertir px:
- Si en cours d'exécution sur un dispositif de mdpi, une image
150 x 150 pxprendra150 * 150 dpde l'espace de l'écran. - Si en cours d'exécution sur un dispositif de hdpi, une image
150 x 150 pxprendra100 * 100 dpde l'espace de l'écran. - Si en cours d'exécution sur un dispositif de xhdpi, une image
150x150 pxprendra75 * 75 dpde l'espace de l'écran.
L'inverse: dire, vous voulez ajouter une image à votre application et vous en avez besoin pour remplir un contrôle 100 * 100 dp. Vous aurez besoin de créer des images de tailles différentes pour les tailles d'écran prises en charge:
- image
100 * 100 pxpour mdpi - image
150 * 150 pxpour hdpi - image
200 * 200 pxpour xhdpi
px Pixels -. Point par échelle correspond à des pixels réels sur l'écran
Pouces -. En fonction de la taille physique de l'écran
mm Millimètres -. En fonction de la taille physique de l'écran
pt Points -. 1/72 de pouce en fonction de la taille physique de l'écran
dp
Densité - pixels indépendants - une unité abstraite qui est basée sur la densité physique de l'écran.
Ces unités sont par rapport à un écran 160 dpi, donc une dp est un pixel sur un écran de 160 dpi. Le rapport du DP-à-pixel change avec la densité de l'écran,
mais pas nécessairement en proportion directe.
Remarque:. Le compilateur accepte les dip et dp, bien que dp est plus compatible avec sp
sp
Pixels -Scale indépendant - c'est comme l'unité de dp,
mais il est également mis à l'échelle par la préférence de taille de la police de l'utilisateur.
Il est recommandé d'utiliser cet appareil lors de la spécification des tailles de police,
ils seront ajustés à la fois la densité de l'écran et les préférences de l'utilisateur.
Prenons l'exemple de deux écrans qui sont de la même taille, mais on a une densité de l'écran de 160 dpi (points par pouce, à savoir les 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
En outre, vous devriez avoir une compréhension claire sur les concepts suivants:
Taille de l'écran:
taille réelle, mesurée en diagonale de l'écran. Pour simplifier, les groupes Android tout écran réelle tailles en quatre tailles: généralisées. petites, normales, grandes et très grandes
Densité de l'écran:
La quantité de pixels à l'intérieur d'une zone physique de l'écran; habituellement dénommée dpi (points par pouce). Par exemple, un écran de densité « faible » a moins de pixels dans une zone physique donnée, par rapport à un écran de masse volumique « normale » ou « élevé ». Pour la simplicité, groupes Android toutes les densités d'écran réelles en quatre généralisés densités:. faible, moyenne, haute et extra haute
Orientation:
L'orientation de l'écran du point de vue de l'utilisateur. C'est portrait ou paysage, ce qui signifie que le le ratio d'aspect de l'écran est large ou haut, respectivement. Savoir que non seulement les différents appareils fonctionnent dans des orientations différentes par défaut, mais l'orientation peut changer lors de l'exécution lorsque l'utilisateur fait tourner l'appareil.
Résolution:
Le nombre total de pixels physiques sur un écran. Lors de l'ajout du support pour de multiples écrans, les applications ne fonctionnent pas directement à la résolution; les demandes doivent être concernées uniquement avec l'écran taille et densité, comme indiqué par la taille et la densité généralisée groupes.
pixel Densité indépendante (dp):
Une unité de pixel virtuel que vous devez utiliser lors de la définition de l'interface utilisateur mise en page, d'exprimer les dimensions de mise en page ou la position d'une manière indépendante de la densité. Le pixel de densité indépendant est équivalent à un pixel physique sur un écran 160 dpi, qui est le la densité de base pris en charge par le système pour un écran de densité « moyenne ». Lors de l'exécution, le système traite de manière transparente toute mise à l'échelle de la dp unités, selon les besoins, en fonction de la densité réelle de l'écran en cours d'utilisation. La conversion des unités de dp de pixels de l'écran est simple: px = dp * (dpi / 160). Par exemple, sur un écran 240 dpi, 1 dp est égal à 1,5 physique pixels. Vous devriez toujours utiliser des unités dp lors de la définition de votre l'interface utilisateur de l'application, afin de garantir un affichage correct de l'interface utilisateur sur les écrans avec densités différentes.
Référence: site développeurs Android
dp est dip. Utilisez-le pour tout (margin, padding, etc.).
Utilisez sp pour {text-size} seulement.
Pour obtenir la même taille sur différentes densités d'écran, Android traduit ces unités en pixels lors de l'exécution, donc il n'y a pas de mathématiques difficile pour vous de le faire.
voir la différence entre px, dp et sp sur différentes tailles d'écran.
Je l'ai calculé la formule ci-dessous pour effectuer les conversions de dpi à dp et sp
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'écran.
Android donne des noms d'alias à plusieurs densités
- LDPI (faible) ~ 120dpi
- mdpi (moyen) ~ 160dpi
- hdpi (haute) ~ 240dpi
- la plupart des appareils en 2015 sont ici
- xhdpi (extra-haute) ~ 320dpi
- Apple iPhone 4/5/6, Nexus 4
- xxhdpi (extra-extra-haute) ~ 480dpi
- Nexus 5
- xxxhdpi (extra-extra-extra-haute) ~ 640dpi
dip ou dp sont pixels de densité-indenpendant , soit ils correspondent à plus ou moins de pixels en fonction de la densité physique.
- 1DP = 1px sur mdpi
sp ou sip est un pixel échelle indépendante . Ils sont mis à l'échelle lorsque le Grand texte est activée dans Paramètres > Accessibilité
- 1sp = 1DP
- 1sp = 1.2dp Accessibilité Grand texte
Qu'est-ce à utiliser?
Utilisez sp Taille du texte.
Utilisez dp pour tout le reste.
Source 3 : (données de la source 3 est donnée ci-dessous)
Ce sont des valeurs de dimension définies dans XML. Une dimension est spécifiée avec un nombre suivi d'une unité de mesure. Par exemple: 10px, 2po, 5sp. Les unités de mesure suivantes sont prises en charge par Android:
dp
Pixels indépendants de la densité - Une unité abstraite qui est basée sur la la densité physique de l'écran. Ces unités sont par rapport à un 160 dpi (points par pouce), sur lequel l'écran 1DP est à peu près égal à 1 pixel. Quand en cours d'exécution sur un écran de densité plus élevée, le nombre de pixels utilisé pour dessiner 1DP est mis à l'échelle par un facteur approprié pour le dpi de l'écran. De même, lorsque sur un écran de faible densité, le nombre de pixels utilisés pour 1DP est réduite. Le rapport du DP-à-pixel va changer avec le la densité de l'écran, mais pas nécessairement en proportion directe. L'utilisation dp unités (au lieu d'unités Px) est une solution simple à faire le point de vue dimensions dans votre mise en page redimensionnent correctement pour écran différent densités. En d'autres termes, il assure la cohérence pour le monde réel tailles de vos éléments d'interface utilisateur à travers différents dispositifs.
sp
Pixels indépendantes de l'échelle - C'est comme l'unité dp, mais il est aussi mis à l'échelle par la préférence de taille de la police de l'utilisateur. Il est recommandé d'utiliser cette unité lors de la spécification des tailles de police, donc ils seront ajustés pour à la fois la densité de l'écran et la préférence de l'utilisateur.
pt
Points -. 1/72 de pouce en fonction de la taille physique de l'écran
px
Pixels - correspond à des pixels réels sur l'écran. Cette unité de mesure n'est pas recommandée, car la représentation réelle peut varier dispositifs à travers; chaque dispositif peut comporter un nombre différent de pixels par pouces et peut avoir plus ou moins de pixels au total disponibles à l'écran.
mm
Millimètres - Sur la base de la taille physique de l'écran
.
pouces -. Sur la base de la taille physique de l'écran
Remarque: Une dimension est simple ressource qui est référencé en utilisant la valeur fournie dans l'attribut name (pas le nom du fichier XML). En tant que tel, vous pouvez combiner les ressources de dimension avec d'autres ressources simples dans un seul fichier XML, sous un même élément.
En fait la seule fois où px applique est un px, et qui est si vous voulez exactement un pixel à l'écran comme dans le cas d'un diviseur:
> 160 dpi, vous pouvez obtenir 2-3 pixels,
> 120 dpi, arrondit à 0.
px
Pixels - correspond à des pixels réels sur l'écran
.dp ou dip
pixels de densité indépendante - une unité abstraite qui est basée sur la densité physique de l'écran. Ces unités sont par rapport à un écran 160 dpi, donc une dp est un pixel sur un écran de 160 dpi.
Utilisation de dp:
l'indépendance de la densité - Votre application permet d'obtenir « l'indépendance de densité » lorsqu'elle préserve la taille physique (du point de vue de l'utilisateur) des éléments d'interface utilisateur lors de l'affichage sur les écrans avec des densités différentes. (Ie) L'image devrait ressembler à la même taille (pas agrandie ou rétreint) dans différents types d'écrans.
sp
Pixels indépendantes de l'échelle - c'est comme l'unité dp, mais il est également mis à l'échelle par la préférence de taille de la police de l'utilisateur
.http://developer.android.com/guide/topics/resources/more -resources.html # Dimension
Où utiliser ce et relation entre px et dp?
pixel de densité indépendant (dp)
Une unité de pixel virtuel que vous devez utiliser lors de la définition de l'interface utilisateur mise en page, pour exprimer les dimensions ou la position de mise en page d'une manière indépendante de la densité. Comme décrit ci-dessus, le pixel de densité indépendant est équivalent à un pixel physique sur un écran 160 dpi, qui est la densité de référence pris en charge par le système pour un écran de densité « moyen ». Lors de l'exécution, le système traite de manière transparente toute mise à l'échelle des unités dp, au besoin, en fonction de la densité réelle de l'écran en cours d'utilisation. La conversion des unités de dp de pixels de l'écran est simple:
px = dp * (dpi / 160).
Par exemple, sur un écran de 240 dpi, une dp est égale à 1,5 pixels physiques. Vous devriez toujours utiliser des unités dp lors de la définition de l'interface utilisateur de votre application, afin d'assurer affichage correct de l'interface utilisateur sur les écrans avec des densités différentes.
pixel Comprendre Dp et vice versa est essentiel (en particulier pour donner des valeurs exactes dp à 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 pixel en nombre pair de l'équipe créative. Sinon, la précision se passera perdre tout en multipliant par 0,5.
px
Il est expliqué ci-dessus. Essayez d'éviter dans les fichiers de mise en page. Mais il y a des cas où px est nécessaire. par exemple, la ligne de séparation de liste. px est mieux ici pour donner une ligne d'un pixel comme un diviseur pour tous dans les résolutions d'écran.
sp
Utilisez sp pour les tailles de police. Alors que la police dans l'application changera alors que les changements de taille des polices de périphérique (qui est, affichage -> Polices sur l'appareil). Si vous voulez conserver une police de taille statique à l'intérieur de l'application, vous pouvez donner la dimension de la police dans dp. Dans ce cas, il 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, il est recommandé sp.
Vous pouvez voir la différence entre px et dp de l'image ci-dessous, et vous pouvez également constater que la px et dp ne pouvaient pas garantir les mêmes dimensions physiques sur les différents écrans.
Tout ce qui concerne la taille du texte et de l'apparence doit utiliser sp ou pt. Considérant que, tout ce qui concerne la taille des commandes, les mises en page, etc. doit être utilisé avec dp.
Vous pouvez utiliser les deux dp et dip à ses lieux.
Je n'utiliser que dp.
Il y a beaucoup de discussions sur l'utilisation de « sp » pour la taille des polices, et si je comprends le point, je ne pense pas que ce soit la bonne chose à faire d'un point de vue de la conception. Vous pouvez finir par casser votre conception si l'utilisateur a une sélection de taille de la police bancale, et l'utilisateur finissent par blâmer l'application , et non leurs propres choix de vie.
En outre, si vous prenez une application-police sp sur une tablette de 160 dpi, vous constaterez que tout échelles ... mais votre police, qui va chercher minuscule en comparaison. Il est pas un bon regard.
Bien que l'idée des polices « sp » a un bon cœur, il est une mauvaise idée. Stick avec dp pour tout.
sp = échelle pixel indépendant
dp = dip = densité de pixels indépendants
dpi = points par pouce
Nous devons éviter d'utiliser sp .
Nous devrions utiliser dp pour prendre en charge plusieurs écrans.
Android supporte différentes résolutions d'écran
- LDPI (bas) ~ 120 dpi
- mdpi (moyen) ~ 160 dpi
- hdpi (haut) ~ 240 dpi
- xhdpi (extra-haute) ~ 320 dpi
- xxhdpi (extra-extra-haute) ~ 480 dpi
- xxxhdpi (extra-extra-extra-haute) ~ 640 dpi
Dispositif de LDPI 120 dp possède 120 pixels dans la taille de 1 pouce.
La même chose pour d'autres densités ...
Nous, les ingénieurs logiciels doivent utiliser cette formule de conversion:
pixel = dp * (densité / 160)
1 dp du dispositif 240 dpi aura = 1 * (240/160) = 3/2 = 1,5 pixels.
480 1 dp du dispositif dpi aura = 1 * (480/160) = 3 pixels.
En utilisant cette connaissance 1,5 et 3 pixels, un ingénieur logiciel peut concevoir des mises en page différentes densités.
Pour vérifier les paramètres de l'écran de tout 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 les unités de dp et sp mentionnées comme « préférence de taille de la police de l'utilisateur » par les réponses copiées à partir des documents officiels peut être vu au moment de l'exécution en changeant l'option Settings->Accessibility->Large Text.
option Large Text texte des forces pour devenir des temps de 1.3 plus.
private static final float LARGE_FONT_SCALE = 1.3f;
Cela pourrait être bien du fournisseur de cours dépend car il se trouve dans packages / apps / paramètres .
dpi -
- points par pouce
- Mesure de la densité de pixels de l'écran.
px - pixel
- Pour les pixels de l'écran de cartographie
pt - points
- A propos de 1/72 de pouce, par rapport à la taille de l'écran physique.
- pouce -. Par rapport à la taille de l'écran physique (1 pouce = 2,54 cm)
mm- milimeter -. Par rapport à la taille de l'écran physique
sp -. Pixel échelle indépendante
- Sur la base de User`s taille de la police préférence.
- police doit être «sp.
dip -
- dip == dp
- Densité pixel indépendant.
- Il varie en fonction de la densité de l'écran.
- Dans l'écran 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 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
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 aller
Il définit le "DENSITY_ *" constantes.
- LDPI (faible) ~ 120dpi
- mdpi (moyen) ~ 160dpi
- hdpi (haute) ~ 240dpi
- xhdpi (extra-haute) ~ 320dpi
- xxhdpi (extra-extra-haute) ~ 480dpi
- xxxhdpi (extra-extra-extra-haute) ~ 640dpi
triera beaucoup de confusion lors de la traduction entre px et dp, si vous connaissez votre écran dpi.
Alors, 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 dans Android sont regroupées en catégories small, medium, large, extra large, double-extra et triple-extra. la densité de l'écran est le nombre de pixels dans une zone (comme pouces) de l'écran. En général, elle est mesurée en points par pouce (dpi). la densité de l'écran est groupée basse, moyenne, haute et très haute. La résolution est le nombre total de pixels dans l'écran.
- dp: densité de pixel indépendant, il varie en fonction de la densité de l'écran. Dans l'écran 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 Android dip a été utilisé et plus tard changé pour dp.
- sp: échelle de pixel indépendant, mis à l'échelle en fonction de la taille de la police de l'utilisateur préférence. Les polices doivent utiliser sp.
- px:. notre pixel standard habituelle qui associe au pixel de l'écran
- . pouces, par rapport à la taille de l'écran physique
- mm. Mm , par rapport à la taille de l'écran physique
- pt:. 1/72 de pouce, par rapport à la taille de l'écran physique
Formule pour la 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 basé sur la taille du seau de 120 (LDPI), 160 (MDPI), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) et 640 (xxxhdpi). Le rapport Google suggéré pour la conception est de 3: 4: 6: 8: 12 pour LDPI: mdpi: hdpi: xhdpi: xxhdpi
Une image 150px X 150px occupera,
- 150 X 150 dp dp espace écran en mdpi
- 100 x 100 dp dp espace écran dans hdpi
- 75 dp X 75 dp espace écran dans xhdpi
Vous pouvez utiliser la calculatrice DPI suivant pour corriger vos tailles d'image et d'autres dimensions lorsque vous souhaitez avoir une conception de l'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);
}
}
Plus d'informations reportez-vous le lien suivant.
http: / /javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/
- px -. Un pixel, identique à celui utilisé en CSS, JavaScript, etc
- sp - pixels à grande échelle indépendante
- dip - densité de pixels indépendant
Normalement sp est utilisé pour les tailles de police, alors que dip est utilisé (également appelé dp) pour les autres.
S'il vous plaît lire la réponse de la communauté wiki. Mentionnés ci-dessous quelques informations à considérer en plus des réponses ci-dessus.
sp = échelle pixel indépendant
dp = densité de pixels indépendants
= ppp pixels de densité
Je suis passé par les réponses ci-dessus ... ne pas les trouver tout à fait correct. sp pour la taille du texte, dp pour limites de présentation - standard. Mais sp pour la taille du texte brisera la mise en page si elle est utilisée négligemment dans la plupart des appareils.
sp prendre la textsize du dispositif, tandis que dp prendre que la norme de densité de dispositif (jamais modifier dans un dispositif) Dites texte peut 100sp occupe 80% de l'écran ou 100% de l'écran en fonction de la taille de la police définie dans l'appareil
Vous pouvez utiliser sp pour les limites de mise en page aussi, il fonctionnera :) Aucune utilisation de standard de l'application sp pour tout le texte
Utilisez sp et dp pour la taille du texte considérant UX.
- Ne pas utiliser sp texte dans la barre d'outils (peut utiliser Android dimens disponible pour différentes tailles d'écran avec dp)
- Ne pas utiliser sp pour le texte en petits boutons bornés, très petit texte, etc
Certaines personnes utilisent énorme taille de police dans leur téléphone pour plus de lisibilité, en leur donnant un petit texte de taille dans le programme seront un problème UX. Mettez sp pour le texte si nécessaire, mais assurez-vous qu'il ne cassera pas la mise en page.
De même, si vous avez une application unique supportant toutes les dimensions, l'ajout d'actifs xxxhdpi augmente la taille de l'application beaucoup. Mais maintenant, les téléphones xxxhdpi sont communs donc nous devons inclure les actifs de xxxhdpi atleast pour les icônes dans la barre latérale, barre d'outils et barre inférieure. Il est préférable de passer à des images vectorielles avoir un uniforme et des images de meilleure qualité pour toutes les tailles d'écran.
Notez également que les gens utilisent la police personnalisée dans leur téléphone. Ainsi, l'absence d'une police peut poser des problèmes en ce qui concerne l'espacement et tous. Dites la taille du texte 12sp pour une police personnalisée peut prendre quelques pixels supplémentaires que la police par défaut.
Reportez-vous site développeur google pour screendensities et les détails de basedensity pour Android. https://developer.android.com/training/multiscreen/screendensities
Je suis tombé sur un bon article sur la conception des applications Android interface utilisateur pour différentes résolutions d'écran, et je voudrais laisser ici juste pour quelqu'un de recherche dans ce domaine. Oui, je sais qu'il est en quelque sorte décrite dans Google docs (et mentionné dans les postes ci-dessus), je l'ai lu cela, mais ce ne fut pas bon pour moi (oui, je peux être trop stupide)). Il me restait peu claire sur la façon de concevoir dispositions capables de gérer différentes tailles d'écran. Je déteste concept de DP et ainsi de suite, quand j'ai besoin de mettre en œuvre une mise en page de l'interface utilisateur « flexible » pour les écrans différents. (Hey les développeurs iOS - oui, vous avez raison, il est concept de Storyboard)
.Android n'a pas mauvaise conception de l'interface utilisateur, mais manque de fonctionnalités iOS Storyboard, malheureusement. La conception flexible dans l'interface utilisateur Android n'est pas chose facile (au mieux).
va ici l'article qui m'a aidé à comprendre ce qu'il faut faire dans Android pour faire des mises en page différentes tailles d'écran:
jmstudio Blog: - Décider Android App Taille de l'écran
Comment concevoir l'interface utilisateur pour Android Apps différent Taille de l'écran
Pour concevoir une interface utilisateur d'application pour différentes tailles d'écran, notre conception initiale doit répondre à un minimum d'espace requis pour chaque taille de l'écran. Applications définit un la taille minimale (en dp) pour chaque type d'écran généralisé. Voici un guide de taille de l'écran Android.
Lorsque nous obtenons la taille de l'écran dans dp, il ne suffit pas pour nous de concevoir l'interface utilisateur de l'application Android. Pour chaque taille de l'écran, nous avons besoin de préparer graphiques et les images en mode point pour chaque densité. Voici une densité d'écran Android ligne directrice.
Pour le calcul facile, nous pouvons suivre les 3: 4: 6: 8 rapport d'échelle entre les quatre densités généralisées. Si nous créons une image de pixel 36 × 36 pour dispositif LDPI, le reste des densités de taille de photos sera 48 × 48 pour mdpi, 72 × 72 pour hdpi, et 96 × 96 pour xhdpi.
Comment concevoir l'interface utilisateur Android Apps dans Photoshop
De nombreux concepteurs ont des problèmes pour la conception de l'interface utilisateur de l'application Android dans Photoshop ou tout autre pixel outils de conception graphique à base en raison de l'unité de densité indépendante, dp. Les concepteurs ne savent pas comment la carte dp au pixel. Google ne donne pas non plus un guide de conception claire interface utilisateur Android pour eux, mais ils donnent une base formule dp et de la traduction pixel.
Comme la définition applications, 1PD égale à 1PX sous dispositif 160 dpi (de mdpi). Nous voulons donc concevoir une application Android pour xlarge appareil Android avec densité mdpi, nous pouvons définir la taille de notre interface utilisateur en pixel 960 pixels en largeur et 720px de hauteur; Suivez la même règle de mappage, nous pouvons obtenir suivant la taille de l'écran Android App régle de conception de l'interface utilisateur:
AJOUTÉE : Si vous intéressé par l'interface utilisateur "flexible" trop, jetez un oeil à cette bibliothèque: Construire 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 augmente de l'écran (quand on a plus de points / pixels par pouce). A l'inverse de dispositifs ayant une résolution plus faible, le nombre de pixels représentés dans le bloc de dp diminue. Comme il est une unité relative, il a besoin d'avoir une base de référence à comparer. Cette ligne de base est un écran de 160 dpi. Ceci est l'équation: px = dp * (dpi / 160).
2) sp: (scale independent pixels)
Cette unité échelles selon la dpi écran (similaire à dp), ainsi que la taille de la police de l'utilisateur préférence.
3) px: (pixels)
pixels réels ou de points sur l'écran.
Pour plus de détails, vous pouvez visiter
Taille de l'écran dans Android est regroupés en catégories ldpi, mdpi, hdpi, xhdpi, xxhdpi et xxxhdpi. densité de l'écran est la quantité de pixels dans une zone (comme pouces) de l'écran. En général, elle est mesurée en points par pouce (dpi).
PX(Pixels):
- notre pixel standard habituelle qui associe au pixel de l'écran.
pxest destiné aux pixels absolues. Ceci est utilisé si vous voulez donner en termes de pixels absolus pour la largeur ou de la hauteur. Non recommandé.
DP/DIP(Density pixels / Density independent pixels):
-
dip == dp. Dans les versions antérieures Android dip a été utilisé et plus tard changé pourdp. C'est une alternative depx. -
En général, nous utilisons jamais
pxparce qu'il est valeur absolue. Si vous utilisezpxpour définir la largeur ou de la hauteur, et si cette application est en cours de téléchargement dans les appareils de taille d'écran différent, ce point de vue ne sera pas étirer selon la taille de l'écran d'origine. -
dpest fortement recommandé d'utiliser à la place depx. Utilisezdpsi vous voulez parler de la largeur et la hauteur de croître et réduire dynamiquement en fonction des tailles d'écran. -
si nous donnons
dp/dip, Android calcule automatiquement la taille des pixels sur la base de l'écran de taille 160 pixels.
SP(Scale independent pixels):
-
réduite en fonction de la taille de la police de l'utilisateur préférence. Les polices doivent utiliser
sp. -
en mentionnant les tailles de police pour s'adapter à différentes tailles d'écran, utilisez
sp. Ceci est similaire àdp.Usespen particulier pour les tailles de police de croître et se rétrécissent de façon dynamique en fonction des tailles d'écran
Android Documentation dit:
en spécifiant des dimensions, utilisez toujours soit
dpou unités desp. Undpest un pixel de densité indépendant qui correspond à la taille physique d'un pixel à 160dpi. Unspest la même unité de base, mais est mis à l'échelle par le la taille du texte préféré de l'utilisateur (c'est un pixel d'échelle indépendant), de sorte que vous devrait utiliser cette unité de mesure lors de la définition la taille du texte
L'écran d'un téléphone mobile est composé de milliers de petits 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é, la plus nette qu'il devient et rend l'écran du smartphone plus facilement lisible.
résolution de l'écran est mesurée en termes de nombre de pixels sur l'écran. Résolution d'écran est une spécification couramment utilisée lors de l'achat d'un appareil, mais il est en fait pas très utile lors de la conception pour Android parce que la pensée des écrans en termes de pixels ne tient pas compte de la notion de taille physique qui, pour un dispositif tactile est vraiment très important.
densité pixel indépendant (dp ou immersion) permettent au concepteur de créer des actifs qui apparaissent de manière attendue, quelle que soit la résolution ou la densité du dispositif cible.
est égale à un pixel à la densité de référence ou 160 dpi (points par pouce) Une densité de pixel indépendant (dp ou dip).
1 px / 1DP = 160 dpi / 160 dpi
2 px / 1DP = 320 dpi (2x) / 160 dpi
où,
dpi est points par pouce
Alors, à 320 dpi, 1 dp est égale à 2 px.
Formule
px / dp = ppp / 160dpi
points par pouce (dpi) est une mesure de la netteté (à savoir, la densité des points lumineux) sur un écran d'affichage. Les points par pouce pour une résolution d'image donnée différeront en fonction de la taille de l'écran dans l'ensemble depuis le même nombre de pixels sont en cours répartis sur un espace différent.
Travailler avec la densité des pixels indépendants nous aider à faire face à une situation comme celle où vous avez deux appareils avec la même résolution de pixels, mais différant quantité d'espace. Supposons que dans un cas, d'un comprimé et le téléphone a la même résolution de pixel 1280 par 800 pixels (160 dpi) et 800 par 1280 pixels (320 dpi), respectivement.
Maintenant, parce qu'un comprimé est à la densité de base (160 ppp) ses pixels physiques et densité indépendante tailles sont les mêmes, 1280 par 800. Le téléphone d'autre part a une densité de pixels, il a donc la moitié autant densité indépendante pixels comme des pixels physiques. Ainsi, un téléphone a 400 par 640 pixels indépendants densité. Donc, en utilisant un pixel de densité indépendante facilite l'image mentalement cette tablette a beaucoup plus d'espace que le téléphone.
De même, si vous avez deux appareils dotés d'un écran similaire, mais différente densité de pixels, disons est à 800 par 1280 pixels (320 ppp), et l'autre est de 400 par 640 pixels (160 ppp), on n'a pas besoin pour définir dispositions totalement différentes pour ces deux appareils que nous pouvons mesurer les actifs en termes de densité pixel indépendant qui est identique pour les deux appareils.
800 par 1280 pixels (320dpi) = 400 par 640 pixels densité indépendante (dp)
400 par 640 pixels (160 dpi) = 400 par 640 pixels densité indépendante (dp)
Echelle pixels indépendants (sp) est l'appareil préféré pour la taille de la police. Pour des raisons d'accessibilité, Android permet aux utilisateurs de personnaliser la taille de la police de leur appareil. Les utilisateurs qui ont du mal à lire du texte peut augmenter la taille de la police de leur appareil. Vous pouvez normalement trouver cette option dans les paramètres d'affichage sur votre téléphone ou tablette sous la taille de la police. Il est souvent également disponible dans les paramètres d'accessibilité.
Avec échelle pixels indépendants, 16 sp est exactement le même que 16 dp lorsque la taille de la police de l'appareil est normale ou 100%. Mais quand la taille de la police de l'appareil est grand, par exemple 125%, 16 sp se traduira à 20 dp ou 1,25 fois 16.
Si vous utilisez dp comme unité de taille de la police, puis ce morceau de texte a une taille physique spécifique, peu importe si l'utilisateur a personnaliser la taille de la police de l'appareil. L'utilisation d'appareils sp fera une meilleure expérience pour les personnes malvoyantes.
Référence : Udacity , Google
sp: échelle pixel indépendant
Vous devriez l'utiliser avec des textes, car il est mis à l'échelle automatiquement en fonction de la taille de la police qui est utilisée par l'utilisateur dans son appareil.
px: pixel ou élément d'image est le point unique sur l'écran
Avant de répondre à cette question me laisse diminuer le nombre d'unités en premier. Alors là, vous allez:. dp ou dip sont à la fois identiques et sont connus comme pixels indépendants de la densité
1. px - signifie pixels. Les pixels sont un seul point, le point sur un écran. En général, dans l'industrie du mobile est mesurée en ppi (pixels par pouce). la résolution de l'écran est directement proportionnelle à ppi, plus le nombre de pixels par pouce la résolution la plus élevée de l'écran.
Par exemple, si vous dessinez une image d'une taille 200 px * 200 px , son apparence doit être différent sur un dispositif à haute résolution par rapport à une faible dispositif de résolution. La raison en est 200 px image sur un téléphone à faible résolution sera plus grande que sur regarder un appareil à haute résolution.
Ci-dessous les images montrent une résolution de la même image sur différents téléphones -
-
Téléphone à haute résolution d'écran
-
Téléphone avec une résolution d'écran faible
2. immersion ou dp - une unité abstraite qui est basée sur la densité physique de l'écran. Ces unités sont par rapport à un écran 160 dpi, donc une dp est un pixel sur une 160 écran dpi. Le rapport de dp à pixel va changer avec la densité de l'écran, mais pas nécessairement en proportion directe. « L'indépendance de la densité » fait référence à l'affichage uniforme des éléments d'interface utilisateur sur les écrans avec des densités différentes.
- l'image qui montre 80px (image côté gauche) et 80 dp (image à droite) . différence de Google Checkout.
A dp est égale à un pixel physique sur un écran avec une densité de 160 . Pour calculer dp:
dp = (largeur en pixels * 160) / la densité de l'écran
3. sp - signifie pixels évolutifs. En général, sp est utilisé pour les textes sur l'interface utilisateur, et sp conserve les paramètres de police. Par exemple, si un utilisateur sélectionné une police plus grande que 30 sp il à l'échelle automatique apparaisse grande selon une préférence de l'utilisateur.
Je veux fournir un moyen facile de comprendre dp. En fait, je pense que dp est le plus facile à comprendre. dp est juste une unité de longueur physique. Il est de la même dimension que mm ou inch. Il est juste pratique pour nous d'écrire 50dp, 60dp plutôt que 50/160 inch ou 60/160 inch, parce que l'on est juste dp 1/160 inch quelle que soit la taille de l'écran ou la résolution est.
Le seul problème est que, le dpi androïde de certains écrans ne sont pas précis. Par exemple, un écran classé à 160dpi peut avoir en effet 170dpi. Ainsi, le résultat du calcul de dp est floue. Il devrait être à peu près la même que 1/160 inch.
SDP - une unité de taille évolutive -. Fondamentalement, il est pas une unité, mais les ressources de dimension pour la taille d'écran différente
Essayez sdp bibliothèque de Intuit. Il est très pratique pour résoudre les problèmes de l'unité, et vous pouvez soutenir rapidement plusieurs écrans .
Utilisation
android:paddingBottom="@dimen/_15sdp" pour positif et android:layout_marginTop="@dimen/_minus10sdp" pour sdp sdp négatif
Il a une valeur équivalente en dp pour chaque taille dans les dossiers de values-sw<N>dp (sw = smallestWidth).
Attention
Utilisez-le avec soin! Dans la plupart des cas, vous avez encore besoin de 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 bibliothèque GitHub .
