android unité to - Quelle est la difference entre “px”, “dip”, “dp” et “sp”?




15 Answers

De la documentation pour les développeurs Android :

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

  2. dans
    Pouces - basé sur la taille physique de l'écran.
    1 pouce = 2,54 cm

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

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

  5. dp ou dip
    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 des pixels indépendants - ceci 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 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.

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 la documentation de Google Design .

this application peut être utilisée pour calculer les dimensions sur un appareil réel.

cm 108

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

  • px
  • tremper
  • dp
  • sp



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

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

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:

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



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

Taille de l'écran:

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

Densité d'écran:

La quantité de pixels dans une zone physique de l'écran; généralement appelé dpi (points par pouce). Par exemple, un écran 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 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 lors 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é est équivalent à un pixel physique sur un écran de 160 ppp, ce qui correspond à 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 est égal à 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




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




Source 1

Source 2

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

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

dp

Pixels indépendants de la densité - Unité abstraite basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi (points par pouce), sur lequel 1dp est à peu près égal à 1px. Lorsque vous utilisez un écran de densité supérieure, le nombre de pixels utilisés pour dessiner 1dp est augmenté d'un facteur approprié pour le dpi de l'écran. De même, sur un écran de densité inférieure, le nombre de pixels utilisés pour 1dp est réduit. Le rapport dp 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 fournit une cohérence pour les 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 elle est également réduite 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.

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 au total 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.




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 en termes de densité - Votre application atteint «l'indépendance en termes de 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 de 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 mis à l'échelle 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




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




Je voudrais seulement utiliser dp.

Il est beaucoup question 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 arrachée et que l'utilisateur finira par blâmer l'application , et non par ses propres choix de vie.

En outre, si vous utilisez une application sp-font sur une tablette à 160 dpi, vous constaterez que tout se met à l' échelle ... sauf 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.




La différence entre les unités dp et sp mentionnées comme " préférence de la taille de police de l'utilisateur " par les réponses copiées à partir de la documentation officielle peut être constatée au moment de l'exécution en modifiant l'option Settings->Accessibility->Large Text .

Large Text option Large Text force le texte à devenir 1.3 fois plus grand.

private static final float LARGE_FONT_SCALE = 1.3f;

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




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

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




Taille de l' écran en Androidsont regroupées en catégories small, medium, large, extra large, double-extraet 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 précédentes d'Android, dip était utilisé et plus tard changé en dp.
  • sp: pixel indépendant de l'échelle, mis à 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.
  • in: 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 déterminer la taille de vos images et d’autres dimensions lorsque vous souhaitez une interface utilisateur uniforme sur tous les appareils Android.

Calculatrice DPI en Java

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


public class DPICalculator {

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

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

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

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


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

private void calculateDPI() {

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

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

Plus d'informations, voir lien suivant.

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




Je suis tombé sur un bon article sur la conception d'interface utilisateur d'applications Android pour différentes résolutions d'écran, et j'aimerais le laisser ici uniquement pour les personnes cherchant dans ce domaine. 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 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 ce qu'il faut faire dans Android pour créer des dispositions pour différentes tailles d'écran:

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

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

Pour concevoir une interface utilisateur d'application pour différentes tailles d'écran, notre conception initiale doit respecter un espace minimum requis pour chaque taille d'écran. Android définit une taille minimale (en dp) pour chaque type d'écran généralisé. Voici un guide de taille d'écran Android. Lorsque nous obtenons la taille de l'écran en dp, il ne 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 l'interface utilisateur des applications Android dans Photoshop

De nombreux concepteurs ont des problèmes pour concevoir l'interface utilisateur de l'application Android dans Photoshop ou d'autres outils de conception graphique à 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 leur fournit pas non plus de guide de conception d'interface utilisateur Android clair, bien qu'ils donnent une formule de base pour la traduction dp et pixel.

En tant que définition d'Android, 1pd est égal à 1px sous un périphérique de 160 dpi (mdpi). Nous voulons donc concevoir une application Android pour un appareil Android très grand 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 d'interface utilisateur de la taille d'écran de l'application Android:

AJOUTÉ : Si vous êtes également intéressé par l’interface utilisateur "flexible", consultez cette bibliothèque: Un SDK Android qui fournit une nouvelle unité de taille - sdp (dp évolutive). Cette unité de taille s'adapte à la taille de l'écran (ceci est également mentionné dans une réponse ici, à propos de la SDPbibliothèque)

ADDED2 Google a enfin compris l'utilité du concept d'interface utilisateur iOS Storeboard, et voici le ConstraintLayoutmonde Android: 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 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 ligne de base 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> Guide du développeur Android de Dimension
> Écrans




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 dans son appareil.

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




Avant de répondre à cette question, laissez-moi d'abord réduire le nombre d'unités. Alors voilà: dp ou dip sont les mêmes et sont connus comme des 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 à 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 alors être différente sur un périphérique haute résolution par rapport à un périphérique basse résolution. La raison en est qu'une image de 200 pixels sur un téléphone basse résolution sera plus grande que sur un appareil 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 haute résolution d'écran

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

2. dip ou dp - une 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. "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 - représente les 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 a sélectionné une police plus grande que 30 ps, elle sera automatiquement redimensionnée en fonction de ses préférences.




Related