I have a high quality icon. I copied that to drawable-xdpi folder. Can I use icon in drawable-xdpi for low density screens without creating drawable-ldpi folder?
Think it's drawable-xhdpi folder. Yes, Android will look for drawable in the folder that best fits the display type. If it is not found, it will try to determine the next best to use.
yes. Do not put that icon in drawable-ldpi folder.
If your app runs on ldpi device and OS does not found the resources in drawable-ldpi. Then it will use resources from drawable-xhdpi after scaling.
UPDATE
Quality will not be the same..as it is ldpi device.
It will calculate the resolution of new Image like this
resolution of xhdpi icon = x * y
resolution for ldpi will = x/2 * y*2
Why dont u put the image in MDPI or just drawable Folder ?
Related
https://developer.android.com/training/basics/actionbar/adding-buttons.html
The icon attribute requires a resource ID for an image. The name that follows #drawable/ must be the name of a bitmap image you've saved in your project's res/drawable/ directory. For example, "#drawable/ic_action_search" refers to ic_action_search.png.
how to add image to res/drawable/ ?? What size image needed for each type, like xxxdpi,xxdpi
For your First Answer Please Visit Android ImageView example.Copy the image and paste into Eclipse/Android-Studio in the res/drawable directory.
The image name should be in lowercase, otherwise it will end up with
an error.
You should always provide bitmap resources that are properly scaled to each of the generalized density buckets: low, medium, high and extra-high density. This helps you achieve good graphical quality and performance on all screen densities.
To generate these images, you should start with your raw resource in vector format and generate the images for each density using the following size scale:
xhdpi: 2.0
hdpi: 1.5
mdpi: 1.0 (baseline)
ldpi: 0.75
This means that if you generate a 200x200 image for xhdpi devices, you should generate the same resource in 150x150 for hdpi, 100x100 for mdpi, and 75x75 for ldpi devices.
Then, place the files in the appropriate drawable resource directory:
Project/
res/
drawable-xhdpi/
awesomeimage.png
drawable-hdpi/
awesomeimage.png
drawable-mdpi/
awesomeimage.png
drawable-ldpi/
awesomeimage.png
Any time you reference #drawable/awesomeimage, the system selects the appropriate bitmap based on the screen's density.
For more details
http://developer.android.com/guide/practices/screens_support.html
Reference
You should consider mdpi as you base and using that you can create for hdpi, xhdpi and so on
eg. if you mdpi size is 12px X 12px then for hdpi it should be 18px X 18px as hdpi is 1.5 times mdpi
use this link
About Android image and asset sizes
Drag drop image using finder/explorer
Use android design guidlines for icon size ratios
Just copy your images from your syaytem to drawable directory of your project
And for icon sizes you can refer to this answer
https://stackoverflow.com/a/12768159/4211264
What size image needed for each type, like xxxdpi,xxdpi
for icon size.. please refer this site
http://iconhandbook.co.uk/reference/chart/android/
Go to YourProjectName/res/drawable and save your image in this folder.
If u have different sizes you can also use the different drawable folders.
If it is one image for every size just create the new folder "drawable" and save your image there.
So i have a very stupid question. I am new to Android and trying to understand how the resources folder work.
I see that I need subfolders with ldpi, mdpi, hdpi, xhdpi, xxhdpi naming but does the naming of the actual image need to be different?
For example, If I have an image names icon.png.
In iOS: mdpi would be icon.png, xhdpi would be icon#2x.png and xxhdpi would be icon#3x.png.
Do I need to give different naming in Android?
If I put icon.png in 5 different folders with 5 different sizes, would there be a name conflict?
It would be very good if someone can explain it.
I read all standard android explanations but I want to make sure with someone who has actually done it.
Thanks for your time.
Directory Naming:
You do not need to provide a different suffix to your image file name for different screen sizes in Android like you do in iOS. The file name should be exactly the same for all the images of different sizes.
However, you need to follow Google's guidelines/conventions for directory naming. Images are called 'drawables' in Android.
Under the 'res' directory, place each image under a directory called drawable-<suffix>. Replace the <suffix> with the screen density qualifier (i.e., mdpi, hdpi, xhdpi, xxhdpi etc.)
Google recommends that you also create a directory called drawable (with no suffix) for default images. These default images will be used as fallback when Android does not find a specific image size for the user's device.
Example directory structure:
res/
drawable/
icon.png
background.png
drawable-mdpi/
icon.png
background.png
drawable-hdpi/
icon.png
background.png
drawable-xhdpi/
icon.png
background.png
drawable-xxhdpi/
icon.png
background.png
Image Size Ratios:
The correct way to create images for different screen densities is by starting at a base image size for mdpi.
Say for example your base icon size is 48px x 48px. Then:
mdpi: 48px x 48px (1x)
hdpi: 72px x 72px (1.5x)
xhdpi: 96px x 96px (2x)
xxhdpi: 144px x 144px (3x)
xxxhdpi: 192px x 192px (4x)
References:
Directory structure:
http://developer.android.com/guide/topics/resources/providing-resources.html
For size ratio comparison (mdpi vs hdpi vs xhdpi vs xxhdpi) go to:
http://developer.android.com/design/style/iconography.html
If I define drawables for a density qualified folder (eg drawable-hdpi), and also drawables to fall back on in drawable-nodpi, will a high density device use the -hdpi over the -nodpi?
What about if I take it a step further and also have the same setup for -land folders.
I'm not sure what the precedence is for nodpi, but that should never be a problem. It sounds like you are misunderstanding the nodpi qualifier. You should not use nodpi as a fallback for assets that you don't provide at the device's density bucket. The correct fallback is a folder with no density qualifier (e.g. drawable/).
If the system cannot find an asset at the device's density (e.g. it is an ldpi device and you don't have a drawable-ldpi folder), it will fall back to a folder without a density qualifier, *not the nodpi qualifier`.
The nodpi qualifier is used when you want to specify a resource that will be used for all densities and that you do not want Android to scale. Assets in the other density folders (e.g. drawable-xhdpi) will be scaled to the actual screen size. If you use the nodpi qualifier, you should not provide that asset in any other resource folders.
It is also important to note that with screen density qualifiers, Android will also prefer to use a lower density asset over an unqualified resource. If you have an xhdpi device, but you only have a drawable and a drawable-mdpi folder, Android will check for the asset in the mdpi folder before the unqualified folder.
drawable-nodpi will bypass scaling and drawable will use the default scaling:
mdpi = 1x
hdpi = 1.5x
xhdpi = 2x
xxhdpi = 3x
xxxhdpi = 4x
drawable-nodpi is efficient if your code will be doing its own scaling
(or no scaling) and you don't want the image pre-scaled by Android.
There is also drawable-anydpi, just to make things more confusing.
drawable with no specifications will be used if an exact match on density and screen specifications does not exist. drawable-nodpi will be used after drawable.
UPDATE If you have both drawable and drawble-nodpi, the select order is either a more complex rule not documented or Android is broken. Through experimentation I confirmed that devices with screen density < xhdpi will correctly select the drawable image. Devices with screen density >= xhdpi will select the drawable-nodpi.
Selection rule:
1. Pick match to screen density, one of these:
drawable-ldpi
drawable-mdpi
drawable-hdpi
drawable-xhdpi
drawable-xxhdpi
drawable-xxxhdpi
If no match on density, then select one of these
drawable (automatic scaling mdpi=none... xxxhdpi=4x)
drawable-nodpi (no scaling)
drawable-tvdpi
drawable-anydpi (no scaling)
It depends.
First of all nodpi is not a fallback folder. If you have a hdpi device, the system will look for hdpi folder first. nodpi folder contains resources that are not meant to be scaled.
drawable/ can be used as a fallback folder in case device density specific resources are not present.
Then, if we look at the possible Qualifier Values for the Screen Pixel Density(dpi), these are listed as:
ldpi
mdpi
hdpi
xhdpi
xxhdpi
xxxhdpi
nodpi (Non-scaling resources go here)
tvdpi
anydpi (Resources in this folder take highest precedence)
nnndpi
Note: You should put all those resources in the drawable-nodpi folder that you do not wish to be scaled. To support multiple screens, Android prefers to scale down a larger original image instead of scaling up a smaller original image. These resources should not be present in any other drawable-qualifier folder else these might be scaled which kind of defeats the whole purpose.
It must also be noted that:
Using a density qualifier does not imply that the resources are only for screens of that density. If you do not provide alternative resources with qualifiers that better match the current device configuration, the system may use whichever resources are the best match.
Here is the Resource Selection Flowchart that the system uses to find the best match:
The drawable-nodpi qualifier is used when image/asset is not need to be scaled.
Drawable in the other density folders (e.g. drawable-xhdpi) will be scaled to the actual screen size.
drawable-nodpi for constant size in all density devices.
I want to design a background for android application using Photoshop , let's say I have Samsung S4,So I set the resolution to the maximum of that device which is 1080x1920 and 441dpi
Now,my question is where should i insert it in what subfolder of Resources and depending on what we choose that folder
-drawable-hdpi
-drawable-ldpi
-drawable-mdpi
-drawable-xhdpi
-drawable-xxhdpi
What image feature decides on which folder image should be in?
Hopefully, this image will show you which category it falls into:
As you can see everything larger than 400dpi is xxhdpi, so you should place it there.
Also check out the DisplayMetrics page.
EDIT: To answer your last question. There isn't any image feature that determines where it belongs, the folders are simply used to load images with different resolutions onto different screens. For example if the picture containing text has high resolution and you place it on a low density screen, the text would be (physically) too small to read. So you place a higher resolution image in hdpi or xhdpi folder and resize it so it has smaller resolution and place it in ldpi and mdpi folders.
Please refer to this, it is from google!
http://developer.android.com/training/multiscreen/screendensities.html
You should put on drawable-xxhdpi folder.
A brief explanation about the drawable resources:
The drawable resources are, by default, divided in 6 generalized groups based on its pixel density:
ldpi: Low density drawables (~120 dpi)
mdpi: Medium density drawables (~160 dpi)
hdpi: High density drawables (~240 dpi)
xhdpi: XHigh density drawables (~320 dpi)
xxhdpi: XXHigh density drawables (~480 dpi)
xxxhdpi: XXXHigh density drawables (~640 dpi)
The scaling ration between these drawables should be 3:4:6:8:12:16
You only need to provide density-specific drawables for bitmap files (.png, .jpg, or .gif) and Nine-Path files (.9.png). If you use XML files to define shapes, colors, or other drawable resources, you should put one copy in the default drawable directory (drawable/).
Even if you don't provide alternative drawable resources for the different groups of density, the Android system will find the best matching drawable and scale it for you. But is recommended to provide alternative drawable resources in order to ensure to always have smooth drawables in all devices.
You might want to take a look here.
Perhaps we use one image for all ldpi, hdpi, mdpi and xdpi where we need to keep the image(in which folder). This is a bit confusion to me. Can anybody clarify my confusion?
Just keep it in res/drawable.
This is not recommended as the images you use will then not scale well for different device screen sizes. But if you place an image in res/drawable this will work.
Instead of creating all of the different folder buckets, drawable-ldpi, drawable-hdpi, etc. Just create one folder, drawable, and then put your images in there and when Android searchs for the image and doesn't find the other folders it will default to the drawable folder as the only resource. This folder is understood by Android to be equal to the drawable-mdpi and will scale the images accordingly.
EDIT: Also available is the res/drawable-nodpi, This will not scale your image at all and it will retain the same size on all screens.
Take a look at How to Support Multiple Screens
The "default" resources are those that are not tagged with a configuration qualifier. For example, the resources in drawable/ are the default drawable resources. The system assumes that default resources are designed for the baseline screen size and density, which is a normal screen size and a medium density. As such, the system scales default density resources up for high-density screens and down for low-density screens, as appropriate.
So yes, drawable folder is what you are looking for.