Quelle est la différence entre "px", "dip", "dp" et "sp" sur Android?

Quelle est la différence entre:

  • px
  • dip
  • dp et
  • sp

Sur Android?

  • RejectedExecutionException de AsyncTask, mais n'ont pas atteint les limites
  • Comment puis-je implémenter Google Voice Typing dans ma demande?
  • ORMLite avec CursorAdapter dans Android
  • Crypter avec Node.js Crypto module et décrypter avec Java (dans l'application Android)
  • Android: se référant aux ressources dans xml personnalisé
  • Android Horizontal Recycler Voir scroll Direction
  • Problèmes de lancement d'une erreur dans Android Studio lorsque packageDebug à Max OS X
  • La solution setVisibility Android ne s'affiche pas si initialement réglé sur invisible
  • Gradle script to autoversion et inclure le commit hash dans Android
  • DialogFragment en plein écran avec StatusBar translucide
  • Paquet Android AAR pour la bibliothèque native
  • La connexion Twitter a échoué
  • 30 Solutions collect form web for “Quelle est la différence entre "px", "dip", "dp" et "sp" sur Android?”

    À partir de la documentation du développeur Android :

    1. Px
      Pixels – correspond aux pixels réels sur 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
      Pixels indépendant de la densité – une unité abstraite qui est basée sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi, donc un dp est un pixel sur un écran de 160 dpi. Le rapport de dp-to-pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. Remarque: le compilateur accepte "dip" et "dp", mais "dp" est plus cohérent avec "sp".

    6. Sp
      Pixels indépendants de l'échelle – c'est comme l'unité dp, mais il est également mis à l'échelle par la préférence de la taille de la police de l'utilisateur. Il est recommandé d'utiliser cette unité lors de la spécification des tailles de police, de sorte qu'elles seront réglées pour la densité de l'écran et la préférence de l'utilisateur.

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

     +----------------+----------------+---------------+-------------------------------+ | Density Bucket | Screen Density | Physical Size | Pixel Size | +----------------+----------------+---------------+-------------------------------+ | ldpi | 120 dpi | 0.5 x 0.5 in | 0.5 in * 120 dpi = 60x60 px | +----------------+----------------+---------------+-------------------------------+ | mdpi | 160 dpi | 0.5 x 0.5 in | 0.5 in * 160 dpi = 80x80 px | +----------------+----------------+---------------+-------------------------------+ | hdpi | 240 dpi | 0.5 x 0.5 in | 0.5 in * 240 dpi = 120x120 px | +----------------+----------------+---------------+-------------------------------+ | xhdpi | 320 dpi | 0.5 x 0.5 in | 0.5 in * 320 dpi = 160x160 px | +----------------+----------------+---------------+-------------------------------+ | xxhdpi | 480 dpi | 0.5 x 0.5 in | 0.5 in * 480 dpi = 240x240 px | +----------------+----------------+---------------+-------------------------------+ | xxxhdpi | 640 dpi | 0.5 x 0.5 in | 0.5 in * 640 dpi = 320x320 px | +----------------+----------------+---------------+-------------------------------+ 
     +---------+-------------+---------------+-------------+--------------------+ | Unit | Description | Units Per | Density | Same Physical Size | | | | Physical Inch | Independent | On Every Screen | +---------+-------------+---------------+-------------+--------------------+ | px | Pixels | Varies | No | No | +---------+-------------+---------------+-------------+--------------------+ | in | Inches | 1 | Yes | Yes | +---------+-------------+---------------+-------------+--------------------+ | mm | Millimeters | 25.4 | Yes | Yes | +---------+-------------+---------------+-------------+--------------------+ | pt | Points | 72 | Yes | Yes | +---------+-------------+---------------+-------------+--------------------+ | dp | Density | ~160 | Yes | No | | | Independent | | | | | | Pixels | | | | +---------+-------------+---------------+-------------+--------------------+ | sp | Scale | ~160 | Yes | No | | | Independent | | | | | | Pixels | | | | +---------+-------------+---------------+-------------+--------------------+ 

    Vous trouverez plus d'informations dans la documentation Google Design .

    Pour calculer les dimensions sur un appareil réel, cette application peut être utilisée.

    Pratiquement tout à propos de cela et comment obtenir le meilleur support pour de multiples écrans avec différentes tailles et densités est très bien documenté ici:

    • Prise en charge de plusieurs écrans

    Taille de l'écran
    Taille physique réelle, mesurée en diagonale de l'écran. Pour simplifier, Android regroupe toutes les tailles d'écran réelles en quatre tailles généralisées: petites, normales, grandes et extra-grandes.

    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é "faible" a moins de pixels dans une zone physique donnée, par rapport à un écran de densité "normal" ou "haute". Pour simplifier, Android regroupe toutes les densités d'écran réelles en six densités généralisées: faible, moyenne, haute, extra-haute, extra-extra-haute et extra-extra-extra-high.

    Orientation
    L'orientation de l'écran du point de vue de l'utilisateur. Il s'agit soit du paysage, soit du portrait, ce qui signifie que le rapport d'aspect de l'écran est large ou grand, respectivement. Sachez que non seulement les différents appareils fonctionnent dans des orientations différentes par défaut, mais l'orientation peut changer à l'exécution lorsque l'utilisateur tourne le périphérique.

    Résolution
    Le nombre total de pixels physiques sur un écran. Lors de l'ajout de support pour 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)
    Une unité de pixels virtuels que vous devriez utiliser lors de la définition de la mise en page UI, pour exprimer les dimensions de la disposition ou la position 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, qui est la densité de base assumé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, si nécessaire, en fonction de la densité réelle de l'écran utilisé. La conversion des unités dp en pixels d'écran est simple: px = dp * (dpi / 160) . Par exemple, sur un écran de 240 dpi, 1 dp est égal à 1,5 pixels physiques. Vous devez toujours utiliser les unités dp lors de la définition de l'interface utilisateur de votre application, afin d'assurer une affichage correct de votre UI sur les écrans avec des densités différentes.

    Si vous êtes sérieux sur le développement d'une application Android pour plus d'un type de périphérique, vous devriez avoir lu les écrans supportant le document de développement au moins une fois. En plus de cela, il est toujours recommandé de connaître le nombre réel de dispositifs actifs ayant une configuration d'écran particulière.

    • Tailles d'écran et densités

    Je vais élaborer plus sur comment exactement dp se transforme en px:

    • Si vous exécutez sur un périphérique mdpi, l'image px 150×150 prendra 150 * 150 dp d'espace d'écran.
    • Si vous exécutez sur un périphérique hdpi, l'image px 150×150 prendra 100 * 100 dp d'espace d'écran.
    • Si vous exécutez sur un périphérique xhdpi, l'image px 150×150 prendra 75 * 75 dp d'espace d'écran.

    À l'inverse: par exemple, vous souhaitez ajouter une image à votre application et vous en avez besoin pour remplir le 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
    • 150 * 150 px Image pour hdpi
    • 200 * 200 px image pour xhdpi

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

    En pouces – en fonction de la taille physique de l'écran.

    Mm millimètres – en fonction de la taille physique de l'écran.

    Points pt – 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 relatives à un écran de 160 dpi, donc un dp est un pixel sur un écran de 160 dpi. Le rapport de dp-to-pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. Remarque: Le compilateur accepte à la fois dip et dp , bien que dp soit plus compatible avec sp .

    Sp Scale – Pixels indépendants – c'est comme l'unité dp , mais il est également mis à l'échelle par la préférence de la taille de la police de l'utilisateur. Il est recommandé d'utiliser cette unité lors de la spécification des tailles de police, de sorte qu'elles seront ajustées pour la densité de l'écran et la préférence de l'utilisateur.

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

      Lower resolution screen Higher resolution, same size Physical Width 1.5 inches 1.5 inches Dots Per Inch (“dpi”) 160 240 Pixels (=width*dpi) 240 360 Density (factor of baseline 160) 1.0 1.5 Density-independent Pixels 240 240 (“dip” or “dp” or “dps”) Scale-independent pixels (“sip” or “sp”) Depends on user font size settings same 

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

    Taille de l'écran:

    Taille physique réelle, mesurée en diagonale de l'écran. Pour simplifier, Android regroupe toutes les tailles d'écran réelles en quatre tailles généralisées: petites, normales, grandes et extra larges.

    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é "faible" a moins de pixels dans une zone physique donnée, par rapport à un écran de densité "normal" ou "haute". Pour simplifier, Android regroupe toutes les densités d'écran réelles en quatre densités généralisées: faible, moyenne, haute et plus élevée.

    Orientation:

    L'orientation de l'écran du point de vue de l'utilisateur. Il s'agit soit du paysage, soit du portrait, ce qui signifie que le rapport d'aspect de l'écran est large ou grand, respectivement. Sachez que non seulement les différents appareils fonctionnent dans des orientations différentes par défaut, mais l'orientation peut changer à l'exécution lorsque l'utilisateur tourne le périphérique.

    Résolution:

    Le nombre total de pixels physiques sur un écran. Lors de l'ajout de support pour 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):

    Une unité de pixels virtuels que vous devriez utiliser lors de la définition de la mise en page UI, pour exprimer les dimensions de la disposition ou la position 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, qui est la densité de base assumé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, si nécessaire, en fonction de la densité réelle de l'écran utilisé. La conversion des unités dp en pixels d'écran est simple: px = dp * (dpi / 160). Par exemple, sur un écran de 240 dpi, 1 dp est égal à 1,5 pixels physiques. Vous devez toujours utiliser les unités dp lors de la définition de l'interface utilisateur de votre application, afin d'assurer une affichage correct de votre UI sur les écrans avec des densités différentes.

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

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

    Utilisez sp pour {text-size} uniquement.


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


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

    Entrez la description de l'image ici

    Source: programmation Android: le guide Big Nerd Ranch

    J'ai calculé la formule ci-dessous pour transformer les conversions dpi en dp et sp Entrez la description de l'image ici

    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 dans 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 densité – Un module abstrait basé sur la densité physique de l'écran. Ces unités sont relatives à un écran de 160 dpi (points par pouce), sur lequel 1dp est approximativement égal à 1px. Lors de l'exécution sur un écran de densité plus élevée, le nombre de pixels utilisés pour dessiner 1dp est étendu par un facteur approprié pour le dpi de l'écran. De même, dans un écran à densité inférieure, le nombre de pixels utilisés pour 1dp est réduit. Le rapport de dp-to-pixel changera avec la densité de l'écran, mais pas nécessairement en proportion directe. L'utilisation d'unités dp (au lieu d'unités px) est une solution simple pour que les dimensions de la vue dans votre mise en page redimensionnent correctement pour différentes densités d'écran. En d'autres termes, il fournit une cohérence pour la taille du monde réel de vos éléments d'IU à travers différents appareils.

    Sp

    Pixels indépendants de l'échelle – C'est comme l'unité dp, mais il est également mis à l'échelle par la préférence de la taille de la police de l'utilisateur. Il est recommandé d'utiliser cette unité lors de la spécification des tailles de police, de sorte qu'elles seront réglées pour 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 aux pixels réels sur l'écran. Cet unité de mesure n'est pas recommandée car la représentation réelle peut varier d'un appareil à l'autre; Chaque périphérique peut avoir un nombre de pixels par pouce différent et peut avoir plus ou moins de pixels disponibles sur l'écran.

    Mm

    Millimètres – Selon la taille physique de l'écran.

    dans

    Pouces – Selon la taille physique de l'écran.

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

    Fondamentalement, le seul moment où px s'applique est un px, et c'est si vous voulez exactement un pixel sur l'écran comme dans le cas d'un diviseur. Sur> 160, vous pouvez obtenir 2-3 pixels, et sur 120dpi, il tourne à 0.

    Définitions

    Px ou dot 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 des noms d'alias à plusieurs densités

    • Ldpi (bas) ~ 120dpi
    • Mdpi (moyen) ~ 160dpi
    • Hdpi (haut) ~ 240dpi
      • La plupart des appareils en 2015 sont ici
    • Xhdpi (extra-high) ~ 320dpi
      • Apple iPhone 4/5/6, Nexus 4
    • Xxhdpi (extra-extra-high) ~ 480dpi
      • Nexus 5
    • Xxxhdpi (extra-extra-extra-high) ~ 640dpi

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

    • 1dp = 1px sur mdpi

    Entrez la description de l'image ici

    Sp ou sip est un pixel indépendant de l'échelle . Ils sont mis à l'échelle lorsque l'option Large Text est activée dans Paramètres > Accessibilité

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

    Que faut-il utiliser?

    Utilisez sp pour la taille du texte.

    Utilisez dp pour tout le reste.

    Où utiliser quoi et relation entre px & dp?

    Pixel indépendant de la densité (dp)

    Une unité de pixels virtuels que vous devriez utiliser lors de la définition de la mise en page UI, pour exprimer les dimensions de la disposition ou la position 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 à 160 ppp, qui est la densité de base assumé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, si nécessaire, en fonction de la densité réelle de l'écran utilisé. La conversion des unités dp en pixels d'écran est simple:

    Px = dp * (dpi / 160).

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

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

     dp = px * 160 / dpi MDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp For example, if you want to convert 20 pixel to dp, use the above formula, dp = 20 * 160 / 160 = 20. So, 20 pixel = 20 dp. HDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp XHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp XXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp For example, let us consider Nexus 4. If 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can convert it to dp easily by the following calculation : dp = 24 * 160 / 320 = 12 dp Screen dimension: 768 x 1280 pixel resolution (320 ppi or 320dpi) Optional (screen size): 4.7" diagonal 
    • Essayez d'obtenir toutes les valeurs de pixels dans des nombres pairs de l'équipe créative. Sinon, la perte de précision se produira 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 quelques cas, où px est requis. Par exemple, la ligne diviseur ListView. Px est mieux ici pour donner une ligne à un pixel en tant que 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 va changer lorsque la taille des polices du périphérique change (c'est-à-dire Affichage -> Polices sur périphérique). Si vous souhaitez conserver une police de taille statique dans l'application, vous pouvez donner la dimension de la police dans dp. Dans un tel cas, il ne changera jamais. Les développeurs peuvent avoir une telle exigence pour certains écrans spécifiques, pour cela, les développeurs peuvent utiliser dp au lieu de sp. Dans tous les autres cas, sp est recommandé.

    Px

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

    Dp ou dip

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

    Utilisation de dp:

    L'indépendance de la densité – Votre application atteint 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'ils sont affichés sur des écrans avec des densités différentes. (C.-à-d.) L'image devrait ressembler à la même taille (pas agrandie ou réduite) dans différents types d'écrans.

    Sp

    Pixels indépendants de l'échelle – c'est comme l'unité dp, mais il est également mis à l'échelle par la préférence de la taille de la 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 le px et le dp ne pouvaient pas garantir les mêmes dimensions physiques sur les différents écrans.

    Entrez la description de l'image ici

    Tout ce qui concerne la taille du texte et de l'apparence doit utiliser sp ou pt . Alors que tout ce qui concerne la taille des commandes, les mises en page, etc. doivent être utilisés avec dp .

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

    J'utiliserais seulement dp.

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

    En outre, si vous prenez une application sp-font sur une tablette de 160 dpi, vous constaterez que tout se balançait … mais votre police, qui sera très petite en comparaison. Ce n'est pas un bon regard.

    Alors que l'idée des polices "sp" a un 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 la police de l'utilisateur » par les réponses copiées à partir de la documentation officielle peut être visualisée au moment de l'exécution en modifiant l'option Settings->Accessibility->Large Text .

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

     private static final float LARGE_FONT_SCALE = 1.3f; 

    Cela peut être bien sûr dépendant du fournisseur car il réside dans les packages / applications / Paramètres .

    Sp = pixel indépendant de l'échelle

    Dp = dip = pixels indépendants de densité

    Dpi = points par pouce

    Nous devrions éviter d'utiliser sp .

    Nous devrions utiliser dp pour supporter plusieurs écrans.

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

    • Ldpi (faible) ~ 120 dpi mdpi (moyen) ~ 160 dpi hdpi (haut) ~ 240 dpi xhdpi
    • (Extra-élevé) ~ 320 dpi xxhdpi (extra-extra-high) ~ 480 dpi xxxhdpi
    • (Extra-extra-extra-high) ~ 640 dpi

    Un appareil ldpi de 120 dp possède 120 pixels en 1 pouce de taille.

    La même chose pour d'autres densités …

    Nous, en tant qu'ingéniciens logiciels, utiliserons ces formules de conversion:

    Pixel = dp * (densité / 160)

    Ainsi, les 1 ppp du périphérique de 240 ppp auront = 1 * (240/160) = 3/2 = 1,5 pixels.

    Et les périphériques de 480 ppp 1 dp auront = 1 * (480/160) = 3 pixels.

    En utilisant cette connaissance de 1,5 et 3 pixels, un ingénieur logiciel peut concevoir des mises en page pour différentes densités.

    Pour vérifier les paramètres d'écran de n'importe quel 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(); 

    Dpi –

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

    Px – pixel

    • Pour la cartographie des pixels de l'écran

    Points pt

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

    En pouces – en ce qui concerne la taille de l'écran physique (1 pouce = 2,54 cm).

    Mm-millimètre – en ce qui concerne la taille de l'écran physique.

    Pixel sp-scale-independent.

    • Selon la préférence de la taille de la police de l'utilisateur.
    • La police devrait être dans 'sp'.

    Dip –

    • Dip == dp
    • Pixel indépendant de la densité.
    • Il varie en fonction de la densité de l'écran.
    • Dans l'écran de 160 ppp, 1 dp = 1 pixel.
    • Utilisez dp sauf la taille de la police de texte.

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

    Formule de conversion des unités:

    Px = dp * (dpi / 160);

     Density Bucket -> Screen Display => Physical Size => Pixel Size ldpi -> 120 dpi => 0.5 x 0.5 in => 0.5 in * 120 dpi = 60x60 px mdpi -> 160 dpi => 0.5 x 0.5 in => 0.5 in * 160 dpi = 80x80 px hdpi -> 240 dpi => 0.5 x 0.5 in => 0.5 in * 240 dpi = 120x120 px xhdpi -> 320 dpi => 0.5 x 0.5 in => 0.5 in * 320 dpi = 160x160 px xxhdpi -> 480 dpi => 0.5 x 0.5 in => 0.5 in * 480 dpi = 240x240 px xxxhdpi -> 640 dpi => 0.5 x 0.5 in => 0.5 in * 640 dpi = 320x320 px 
    • Px – un pixel, identique à celui utilisé dans CSS, JavaScript, etc.
    • Pixel indépendant de l'échelle sp
    • Pixels dépendant de la densité

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

    Voici la formule utilisée par Android:

    Px = dp * (dpi / 160)

    Lorsque dpi est l'une des densités d'écran suivantes. Pour obtenir une liste de toutes les densités possibles, consultez http://developer.android.com/reference/android/util/DisplayMetrics.html . Il définit les constantes "DENSITY_ *".

    Ldpi (bas) ~ 120dpi mdpi (moyen) ~ 160dpi hdpi (haut) ~ 240dpi xhdpi (extra-élevé) ~ 320dpi xxhdpi (extra-extra-high) ~ 480dpi xxxhdpi (extra-extra-extra-high) ~ 640dpi

    Tiré de http://developer.android.com/guide/practices/screens_support.html .

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

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

    Px = 60 * (240/160)

    La taille de l'écran dans Android est regroupée en 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 (comme pouce) de l'écran. Généralement, il est mesuré en points par pouce (ppp). La densité de l'écran est groupée comme faible, moyenne, haute et plus élevée. La résolution est le nombre total de pixels dans l'écran.

    • Dp: Density Independent Pixel, il varie en fonction de la densité de l'écran. Dans l'écran de 160 ppp, 1 dp = 1 pixel. Sauf pour la taille de la police, utilisez dp toujours.
    • Dip: dip == dp. Dans les versions antérieures de versions, dip a été utilisé et plus tard changé en dp.
    • Sp: Scale Independent Pixel, mis à l'échelle en fonction de la taille de la taille de l'utilisateur. Les polices devraient 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: millimeters, with respect to the physical screen size.
    • pt: 1/72 of an inch, with respect to the physical screen size.

    Formula for Conversion between Units

      px = dp * (dpi / 160) 

    dp to px in device

    Following example may help understand better. The scaling occurs based on bucket size of 120(ldpi), 160(mdpi), 240(hdpi), 320(xhdpi), 480(xxhdpi) and 640(xxxhdpi). The Google suggested ratio for designing is 3:4:6:8:12 for ldpi:mdpi:hdpi:xhdpi:xxhdpi

    A 150px X 150px image will occupy,

    • 150 dp X 150 dp screen space in mdpi
    • 100 dp X 100 dp screen space in hdpi
    • 75 dp X 75 dp screen space in xhdpi

    You may use the following DPI calculator to fix your image sizes and other dimensions when you wish to have an uniform UI design in all Android devices.

    DPI Calculator in 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(){ } 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); } } 

    More Information refer following link.

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

    sp = scale independent pixel

    dp = density independent pixels

    dpi = density pixels

    I have gone through the above answers…not finding them exactly correct. sp for text size, dp for layout bounds – standard. But sp for text size will break the layout if used carelessly in most of the devices.

    sp take the textsize of the device, whereas dp take that of device density standard( never change in a device) Say 100sp text can occupies 80% of screen or 100% of screen depending on the font size set in device

    Entrez la description de l'image ici

    You can use sp for layout bounds also, it will work 🙂 No standard app use sp for whole text

    Use sp and dp for text size considering UX.

    • Dont use sp for text in toolbar( can use android dimens available or dp)
    • Dont use sp for text in small bounded buttons, very smaller text, etc

    Some people use huge FONT in their phone for more readability, giving them small hardcoded sized text will be an UX issue. Put sp for text where necessary, but make sure it won't break the layout.

    I've come across a good article about designing Android apps UI for different screen resolutions, and I'd like to leave it here just for somebody searching in this area. Yes, I know that it's somehow described in Google docs (and mentioned in the posts above), I read that but it was not good for me (yeah, I may be too stupid)). It remained unclear for me how to design layouts capable to handle different screen size. I hate DP concept and so on, when I need to implement a "flexible" UI layout for different screens. (Hey iOS developers – yes, you're right it's Storyboard concept).

    Android has not bad UI concept, but lacks iOS Storyboard features, unfortunately. Designing flexible UI in Android is not easy thing (at the best).

    Here goes the article that helped me to understand what to do in Android to make layouts for different screen sizes:

    http://jmsliu.com/1718/decide-android-app-screen-size.html

    How to Design UI for Android Apps for Different Screen Size

    To design an app UI for different screen sizes, our initial design has to meet a minimum required space for each screen size. Android defines a minimum size (in dp) for each generalized screen type. Here is an Android screen size guideline. Minimum Screen Size for Android in dp When we get the screen size in dp, it is not enough for us to design the Android app UI. For each screen size, we need to prepare graphics and bitmap images for each density. Here is an Android screen density guideline. Android Density Guideline (dpi)

    For easy calculation, we can follow the 3:4:6:8 scaling ratio between the four generalized densities. If we create a 36×36 pixel picture for ldpi device, the rest densities pictures size will be 48×48 for mdpi, 72×72 for hdpi, and 96×96 for xhdpi.

    How to Design Android Apps UI in Photoshop

    Many designers have problems for designing Android app UI in photoshop or other pixel based graphic design tools because of density-independent unit, dp. Designers don't know how to map dp to pixel. Google also doesn't give a clear Android UI design guide for them, though they give a basic formula for dp and pixel translation.

    As Android's definition, 1pd equal to 1px under 160 dpi device (mdpi). So we want to design an Android app for xlarge Android device with mdpi density, we can define our UI size in pixel as 960 pixel in width and 720px in height; Follow the same mapping rule, we can get following Android App screen size UI design guideline:

    Android App Screen Size in Pixel Guideline

    ADDED : If you interested in "flexible" UI too, have a look at this library: An Android SDK that provides a new size unit – sdp (scalable dp). This size unit scales with the screen size (this also mentioned in an answer here, about SDP library)

    ADDED2 Google has finally understood usefulness of iOS Storeboard UI concept, and here goes ConstraintLayout for Android world: Build a Responsive UI with ConstraintLayout (IMHO a must to read for every Android dev).

    Screen size in Android is grouped into categories ldpi , mdpi , hdpi , xhdpi , xxhdpi and xxxhdpi . Screen density is the amount of pixels within an area (like inch) of the screen. Generally it is measured in dots-per-inch ( dpi ).

    PX(Pixels):

    • our usual standard pixel which maps to the screen pixel. px is meant for absolute pixels. This is used if you want to give in terms of absolute pixels for width or height. Not recommended.

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

    • dip == dp . In earlier Android versions dip was used and later changed to dp . This is alternative of px .

    • Generally we never use px because it is absolute value. If you use px to set width or height, and if that application is being downloaded into different screen sized devices, then that view will not stretch as per the screen original size.

    • dp is highly recommended to use in place of px . Use dp if you want to mention width and height to grow & shrink dynamically based on screen sizes.

    • if we give dp/dip , android will automatically calculate the pixel size on the basis of 160 pixel sized screen.

    SP(Scale independent pixels):

    • scaled based on user's font size preference. Fonts should use sp .

    • when mentioning the font sizes to fit for various screen sizes, use sp . This is similar to dp .Use sp especially for font sizes to grow & shrink dynamically based on screen sizes

    Android Documentation says:

    when specifying dimensions, always use either dp or sp units. A dp is a density-independent pixel that corresponds to the physical size of a pixel at 160 dpi . An sp is the same base unit, but is scaled by the user's preferred text size (it's a scale-independent pixel), so you should use this measurement unit when defining text size

    dp: (density independent pixels) The number of pixels represented in one unit of dp will increase as the screen resolution increases (when you have more dots/pixels per inch). Conversely on devices with lower resolution, the number of pixels represented in on unit of dp will decrease. Since this is a relative unit, it needs to have a baseline to be compared with. This baseline is a 160 dpi screen. This is the equation: px = dp * (dpi / 160).

    sp: (scale independent pixels) This unit scales according to the screen dpi (similar to dp) as well as the user's font size preference.

    px (Pixels) – Actual pixels or dots on the screen.

    For more details you can visit

    http://developer.android.com/guide/topics/resources/more-resources.html#Dimension And http://developer.android.com/about/dashboards/index.html#Screens

    The screen of a mobile phone is made up of thousands of tiny dots known as Pixels(px) .A Pixel is the smallest element which goes to make the picture.The more the number of pixels to make a picture or wording, the sharper it becomes and makes the smartphone screen more easily readable.Screen resolution is measured in terms of number of pixels on the screen.Screen resolution is commonly used spec when buying a device,but it's actually not that useful when designing for android because thinking of screens in terms of pixels ignores the notion of physical size,which for touch device is really really important.

    Density independent pixel(dp or dip) allow the designer to create assets that appear in a expected way,no matter the resolution or density of target device. A density independent pixel(dp or dip) is equal to one pixel at the baseline density or 160 dpi(dots per inch)

    1 px/1dp = 160 dpi/160 dpi

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

    where,

    dpi is dots per inch

    So, At 320 dpi, 1dp is equal to 2 px.

    Formula

    px/dp=dpi/160dpi

    dots per inch (dpi) is a measure of the sharpness (that is, the density of illuminated points) on a display screen .The dots per inch for a given picture resolution will differ based on the overall screen size since the same number of pixels are being spread out over a different space.

    Working with density independent pixels help us to deal with situation like where you have two devices with same pixel resolution but differing amount of space.Suppose in a case,a tablet and phone has same pixel resolution 1280 by 800 pixels(160 dpi) and 800 by 1280 pixels(320 dpi) respectively. Now because tablet is at baseline density(160 dpi) its physical and density independent pixels sizes are the same,1280 by 800.The phone on the other hand has a higher pixel density so it has half as many density independent pixels as physical pixels.So phone has 400 by 640 density independent pixels.So using density independent pixel makes it easier to mentally picture that tablet has much more space than the phone.

    Similarly,if you have two devices with similar screen size but different pixel density,say one is,800 by 1280 pixels(320 dpi), and the other is 400 by 640 pixels(160 dpi),we don't need to define totally different layouts for these two devices as we can measure assets in terms of density independent pixel which is same for both devices.

    800 by 1280 pixels(320dpi)=400 by 640 density independent pixel(dp)

    400 by 640 pixels(160 dpi)=400 by 640 density independent pixel(dp)

    Scale independent pixels(sp) is the preferred unit for font size. For accessibility purposes Android allows users to customize their device's font size.Users that have trouble reading text can increase their device's font size.You can normally find this option in the display setting on your phone or tablet under font size.It's often also available through the accessibility settings. With scale independent pixels,16 sp is exactly the same as 16 dp when the device's font size is normal or 100%.But when device's font size is large,for example 125%, 16 sp will translate to 20 dp or 1.25 times 16. If you use dp as unit for font size,than that piece of text has specific physical size no matter if the user has customize device's font size.Using sp units will make a better experience for people with impaired eyesight.

    Reference : Udacity ,Google

    sp: scale independent pixel. You should use it with texts because it is automatically scaled according to the font size that is being used by the user in his device. px: pixel or picture element is the single point on the screen

    SDP – a scalable size unit – basically it is not a unit but dimension resources for different screen size.

    Try sdp library from intuit, it's very handy to solve unit problem and you can quickly support to multiple screens .

    Usage

    android:paddingBottom="@dimen/_15sdp" for positive and android:layout_marginTop="@dimen/_minus10sdp" for negative sdp sdp

    It has equivalent value in dp for each size in values-sw<N>dp folders (sw = smallestWidth)

    Attention

    Use it carefully! in most cases you still need to design a different layout for tablets.

    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> 

    You can use db for text size but I prefer ssp for text size.

    For more details check library git link

    I want to provide an easy way to understand dp . In fact, I think dp is the easiest one to understand. dp is just a physical length unit. It's of the same dimension as mm or inch . It's just convenient for us to write 50dp , 60dp rather than 50/160 inch or 60/160 inch , because one dp is just 1/160 inch whatever the screen size or resolution is.

    The only problem is that, the android dpi of some screens are not accurate. For example, a screen classified to 160dpi may have 170dpi indeed. So the computation result of dp is fuzzy. It should be approximately the same as 1/160 inch .

    The ratio of dp-to-pixel will change with the screen density, but not necessarily in direct proportion.

    Note : The compiler accepts both " dip " and " dp ", though " dp " is more consistent with " sp ".

    Scale-independent Pixels – this is like the dp unit, but it is also scaled by the user's font size preference.

    coAndroid est un fan Android de Google, tout sur les téléphones Android, Android Wear, Android Dev et Android Games Apps.