android - studio - What is the difference between “px”, “dip”, “dp” and “sp”?
sp in android stands for (20)
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
What is the difference between android units of measure?
- px
- dip
- dp
- sp
Definitions
px or dot is a pixel on the physical screen.
dpi are pixels per inch on the physical screen and represent the density of the display.
Android gives alias names to several densities
- ldpi (low) ~120dpi
- mdpi (medium) ~160dpi
- hdpi (high) ~240dpi
- most devices in 2015 are here
- 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 or dp are density-indenpendant pixels, i.e. they correspond to more or less pixels depending on the physical density.
- 1dp = 1px on mdpi
sp or sip is a scale-independant pixel. They are scaled when the Large Text option is turned on in Settings > Accessibility
- 1sp = 1dp
- 1sp = 1.2dp with accessibility Large Text
What to use?
Use sp for Text size.
Use dp for everything else.
1)
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).
2)
sp: (scale independent pixels)
This unit scales according to the screen dpi (similar to dp) as well as the user’s font size preference.
3)
px: (pixels)
Actual pixels or dots on the screen.
For more details you can visit
Android Developer Guide > Dimension
Android Developer Guide > Screens
Source 3: (data from source 3 is given below)
These are dimension values defined in XML. A dimension is specified with a number followed by a unit of measure. For example: 10px, 2in, 5sp. The following units of measure are supported by Android:. attribute (not the name of the XML file). As such, you can combine dimension resources with other simple resources in the one XML file, under one element.
Here's the formula used by Android:
px = dp * (dpi / 160)
Where dpi is one of the following screen densities. For a list of all possible densities go here
It defines the "DENSITY_*" constants.
- ldpi (low) ~120dpi
- mdpi (medium) ~160dpi
- hdpi (high) ~240dpi
- xhdpi (extra-high) ~320dpi
- xxhdpi (extra-extra-high) ~480dpi
- xxxhdpi (extra-extra-extra-high) ~640dpi
This will sort out a lot of the confusion when translating between px and dp, if you know your screen dpi.
So, let's say you want an image of 60 dp for an hdpi screen then the physical pixel size of 60 dp is:
px = 60 * (240 / 160)
Moreover you should have clear understanding about the following four generalized densities: low, medium, high, and.
Reference: Android developers site
Screen Size in
Android is grouped into categories
small,
medium,
large,
extra large,
double-extra and
triple-extra. Screen density is the amount of pixels within an area (like inch) of the screen. Generally it is measured in dots-per-inch (dpi). Screen density is grouped as low, medium, high and extra high. Resolution is the total number of pixels in the screen.
- dp: Density Independent Pixel, it varies based on screen density . In 160 dpi screen, 1 dp = 1 pixel. Except for font size, use dp always.
- dip: dip == dp. In earlier Android versions dip was used and later changed to dp.
- sp: Scale Independent Pixel, scaled based on user’s font size preference. Fonts should use sp.
- px: our usual standard pixel which maps to the screen pixel.
- in: inches, with respect to the physical screen size.
- 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(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.
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.
pxis 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
pxbecause it is absolute value. If you use
pxto 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.
dpis highly recommended to use in place of
px. Use
dpif 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
spespecially for font sizes to grow & shrink dynamically based on screen sizes
Android Documentation says:
when specifying dimensions, always use either
dpor
spunits. A
dpis a density-independent pixel that corresponds to the physical size of a pixel at 160
dpi. An
spis 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
px
Pixels - corresponds to actual pixels on the screen.
dp or dip
Density-independent Pixels - an abstract unit that is based on the physical density of the screen. These units are relative to a 160 dpi screen, so one dp is one pixel on a 160 dpi screen.
Use of dp:
Density independence - Your application achieves “density independence” when it preserves the physical size (from the user’s point of view) of user interface elements when displayed on screens with different densities. (ie) The image should look the same size (not enlarged or shrinked) in different types of screens.
sp
Scale-independent Pixels - this is like the dp unit, but it is also scaled by the user's font size preference.
Anything related with the size of text and appearance must use
sp or
pt. Whereas, anything related to the size of the controls, the layouts, etc. must be used with
dp.
You can use both
dp and
dip at its places.
Before answering this question let me decrease the number of units first. So here you go: dp or dip are both the same and are known as Density-independent pixels.
1. px - stands for pixels. Pixels are a single dot, point on a screen. Generally in the mobile industry it is measured in ppi (pixels per inch). Screen resolution is directly proportional to ppi, the larger the number of pixels per inch the higher the screen resolution.
For example, if you draw an image of a size 200 px * 200 px, then its appearance must be different on a high-resolution device versus a low-resolution device. The reason is a 200 px image on a low-resolution phone will be look larger than on a high-resolution device.
Below images are showing a resolution of the same image on different phones -
Phone with High screen resolution
Phone with Low screen resolution
2. dip or dp -. "Density independence" refers to the uniform display of UI elements on screens with different densities.
- Image which is showing 80px (left side image) and 80 dp (right-side image). Checkout difference.
A dp is equal to one physical pixel on a screen with a density of 160. To calculate dp:
dp = (width in pixels * 160) / screen density
3. sp - stands for scalable pixels. Generally sp is used for texts on the UI, and sp preserves the font settings. For example, if a user selected a larger font than 30 sp it will auto scale to appear large according to a user preference.
Difference between
dp and
sp units mentioned as "user's font size preference" by the answers copied from official documentation can be seen at run time by changing
Settings->Accessibility->Large Text option.
Large Text option forces text to become
1.3 times bigger.
private static final float LARGE_FONT_SCALE = 1.3f;
This might be well of course vendor dependent since it lies in packages/apps/Settings.
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.
I would only use dp.
There is a lot of talk about using "sp" for font sizes, and while I appreciate the point, I don't think that it is the right thing to do from a design point of view. You can end up breaking your design if the user has some wonky font size selection, and the user will end up blaming the app, and not their own life choices.
Also, if you take an sp-font app on a 160 dpi tablet, you will find that everything scales up... but your font, which is going to look tiny in comparison. It isn't a good look.
While the idea of "sp" fonts has a good heart, it is a poor idea. Stick with dp for everything.
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:
JMSTUDIO Blog :- Decide Android App Screen Size
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. 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.
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:
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
Pretty much everything about this and how to achieve the best support for multiple screens with different sizes and densities is very well documented here:.
If you are any serious about developing an Android app for more than one type of device, you should have read the screens support development document at least once. In addition to that it is always a good thing to know the actual number of active devices that have a particular screen configuration.
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 a commonly-used specification 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 a 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
2 px/1dp = 320 dpi(2x)/160 dpi
where,
dpi is dots per inch
So, at 320 dpi, 1 dp 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 a 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 the same pixel resolution 1280 by 800 pixels (160 dpi) and 800 by 1280 pixels (320 dpi) respectively.
Now because a 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 a phone has 400 by 640 density independent pixels. So using a 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 the unit for font size, then that piece of text has a 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
dpi -
- Dots per inches
- Measuring the pixel density of the screen.
px - pixel
- For mapping screen pixels
pt - points
- About 1/72 of an inch, with respect to physical screen size.
in - inch - with respect to physical screen size(1 inch = 2.54 cm).
mm- milimeter - with respect to physical screen size.
sp - scale-independent pixel.
- Based on user`s font size preference.
- Font should be in 'sp'.
dip -
- dip == dp
- Density independent pixel.
- It varies based on Screen Density.
- In 160 dpi screen, 1 dp = 1 pixel.
- Use dp except the text font size.
In standard, dp and sp are used. sp for font size and dp for everything else.
Formula for conversion of units:
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
sp = scale independent pixel
dp = dip = density independent pixels
dpi = dots per inch
We should avoid to use sp.
We should use dp to support multiple screens.
Android supports different screen resolutions
- ldpi (low) ~120 dpi
- mdpi (medium) ~160 dpi
- hdpi (high) ~240 dpi
- xhdpi (extra-high) ~320 dpi
- xxhdpi (extra-extra-high) ~480 dpi
- xxxhdpi (extra-extra-extra-high) ~640 dpi
An 120 dp ldpi device has 120 pixels in 1 inch size.
The same for other densities...
We as software engineers should use this conversion formula:
pixel = dp * (density / 160)
So 240 dpi device's 1 dp will have = 1 * (240/160) = 3/2 = 1.5 pixels.
And 480 dpi device's 1 dp will have = 1 * (480/160) = 3 pixels.
Using this 1.5 and 3 pixels knowledge, a software engineer can design layouts for different densities.
To check screen parameters of any device:
DisplayMetrics metrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(metrics); Toast.makeText( this, "4:" + metrics.heightPixels + "," + metrics.density + "," + metrics.densityDpi, Toast.LENGTH_LONG).show();