There is hdpi and nodpi qualifier folders in my project. Suppose I have installed the app in a hdpi density device. From which qualifier folder will it pick the resources ?
the hdpi resources will be used. Device will first check the corresponding dpi resource folder.
according to doc
The system uses the appropriate alternative resource Based on the size and density of the current screen, the system uses any size- and
density-specific resource provided in your application. For example,
if the device has a high-density screen and the application requests a
drawable resource, the system looks for a drawable resource directory
that best matches the device configuration. Depending on the other
alternative resources available, a resource directory with the hdpi
qualifier (such as drawable-hdpi/) might be the best match, so the
system uses the drawable resource from this directory.
If no matching resource is available, the system uses the default resource and scales it up or down as needed to match the current
screen size and density.
the nodpi resources are also default resources type. The only difference is it doesn't scall the images but drawable does.
drawable-nodpi: This can be used for bitmap resources that you do not want to be scaled to match the device density.
if you have an images with same name in hdpi and nodpi drawable folder when you are running in hdpi it will pick from HDPI darwable only.
There is an image with 100 x 100 px that I want to show in any resolution/density as same size then we need the drawable-nodpi folder.
Related
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.
Which size of an image should be placed in the neutral drawable folder?
I have an icon file in 5 different versions:
24x24 = ldpi
32x32 = mdpi
48x48 = hdpi
64x64 = xhdpi
96x96 = xxhdpi
On the other hand I have 6 different folders:
/drawable
/drawable-ldpi
/drawable-mdpi
/drawable-hdpi
/drawable-xhdpi
/drawable-xxhdpi
5 Files and 6 folders means that either one folder has to stay empty (which one?) or one file has to be used twice?
This is what the docs say:
If no matching resource is available, the system uses the default
resource and scales it up or down as needed to match the current
screen size and density
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.
However, when the system is looking for a density-specific resource
and does not find it in the density-specific directory, it won't
always use the default resources. The system may instead use one of
the other density-specific resources in order to provide better
results when scaling. For example, when looking for a low-density
resource and it is not available, the system prefers to scale-down the
high-density version of the resource, because the system can easily
scale a high-density resource down to low-density by a factor of 0.5,
with fewer artifacts, compared to scaling a medium-density resource by
a factor of 0.75.
OK, that the mdpi version should be placed in drawable-mdpi, ldpi in drawable-ldpi, etc. is out of question. But which version goes to the neutral folder?
Should I place the xxhdpi files there (scale down if no match is found)? What about the -xxhdpi folder than? Keep it empty or place the files there as well?
The default /drawable folder expects mdpi images. And mostly used in 2 cases:
To have non-density dependent images. eg: selectors, which indirectly link to images from density named folders again.
To have all the images in only this folder and ignore all the other drawable folders. In which case the images will be scaled depending on
the screen density.
For your case:
You can keep only xml files like selectors in the default /drawable
folder and other images in their respective folders
I am developing an andriod app using eclipse. I have the following folder structure.
Xml file folder:
/res/layout
/res/layout-large
/res/layout-large-mdpi
/res/layout-mdpi
/res/layout
/res/layout-xlarge
Image folder:
/res/drawable
/res/drawable-hdpi
/res/drawable-ldpi
/res/drawable-mdpi
/res/drawable-xhdpi
/res/drawable-xxhdpi
I have used this code in my manifest.xml
<supports-screens
android:smallScreens="true"
android:normalScreens="true"
android:largeScreens="true"
android:xlargeScreens="true"
android:anyDensity="true" />
I have a logo image of different sizes in the drawable folders. But now all my layout.xml using the image from /res/drawable-mdpi only. How to fix this?
Check(TEST) this before you try!!!
This is not perfect answer for your Question, But this is a chance if you have minimum number of Images in your app:
Go through the developer site here :
and read complete details,
For better results on your app consider 1,2 points before "Using configuration qualifiers" paragraph in the above link.
At runtime, the system ensures the best possible display on the current screen with the following procedure for any given resource:
The system uses the appropriate alternative resource
Based on the size and density of the current screen, the system uses any size- and density-specific resource provided in your application. For example, if the device has a high-density screen and the application requests a drawable resource, the system looks for a drawable resource directory that best matches the device configuration. Depending on the other alternative resources available, a resource directory with the hdpi qualifier (such as drawable-hdpi/) might be the best match, so the system uses the drawable resource from this directory.
If no matching resource is available, the system uses the default resource and scales it up or down as needed to match the current screen size and density
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.
However, when the system is looking for a density-specific resource and does not find it in the density-specific directory, it won't always use the default resources. The system may instead use one of the other density-specific resources in order to provide better results when scaling. For example, when looking for a low-density resource and it is not available, the system prefers to scale-down the high-density version of the resource, because the system can easily scale a high-density resource down to low-density by a factor of 0.5, with fewer artifacts, compared to scaling a medium-density resource by a factor of 0.75.
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.
I'm new to Android development (using Mono for Android), I've read this, this this and a some other questions here on SO but I'm not sure on how to provide all necessary Icon files for my application.
From the template project, the IDE created for me a drawable/ folder with an 48x48 px Icon.png file.
Since I need to provide alternative resources, I grabbed a PNG file which serves as my application icon and used the Android Asset Studio (mentioned in the docs) and it generated the following files for me:
drawable-hdpi/ic_launcher.png (72x72 px)
drawable-mdpi/ic_launcher.png (48x48 px)
drawable-xhdpi/ic_launcher.png (96x96 px)
drawable-xxhdpi/ic_launcher.png (144x144 px)
(I don't know why, but the Android Asset Studio did not generate the ldpi version, so I resized myself a 36x36 icon.)
Now I'm lost
1. Should I maintain a 48x48 px copy in both drawable-mdpi/ and drawable/ ?
If I keep the icon only in the drawable-mdpi/, may the application crash on older devices / versions of the Android (because the default resource is missing)?
1. If I keep the icon only in the drawable/ (the fallback), what is the point in using drawable-mdpi/ at all?
Since I don't know exactly what to do, I'm left my project drawable folders as follows:
drawable/ic_launcher.png (48x48 px)
drawable-hdpi/ic_launcher.png (72x72 px)
drawable-ldpi/ic_launcher.png (36x36 px)
drawable-mdpi/ic_launcher.png (48x48 px)
drawable-xhdpi/ic_launcher.png (96x96 px)
drawable-xxhdpi/ic_launcher.png (144x144 px)
But it is still not clear for me.
EDIT:
If I provide all possible "alternative" resources, then the default (drawable/) resource folder will become redundant, thus I could delete it. However I'm reluctant of not providing the default resources because it seems more reasonable to do the opposite: first provide the "default" resources and then provide "alternative" resources as needed.
This quote is a little long, but you should read though what the documentation has to say about this:
At runtime, the system ensures the best possible display on the current screen with the following procedure for any given resource:
1.The system uses the appropriate alternative resource
Based on the size and density of the current screen, the system uses any size- and density-specific resource provided in your application. For example, if the device has a high-density screen and the application requests a drawable resource, the system looks for a drawable resource directory that best matches the device configuration. Depending on the other alternative resources available, a resource directory with the hdpi qualifier (such as drawable-hdpi/) might be the best match, so the system uses the drawable resource from this directory.
2.If no matching resource is available, the system uses the default resource and scales it up or down as needed to match the current
screen size and density 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.
However, when the system is looking for a density-specific resource
and does not find it in the density-specific directory, it won't
always use the default resources. The system may instead use one of
the other density-specific resources in order to provide better
results when scaling. For example, when looking for a low-density
resource and it is not available, the system prefers to scale-down the
high-density version of the resource, because the system can easily
scale a high-density resource down to low-density by a factor of 0.5,
with fewer artifacts, compared to scaling a medium-density resource by
a factor of 0.75.
So, the system will look for the best sized drawable for whatever device the application is running on. If the system is looking for a launcher icon of 48x48, it will look in drawable-mdpi/ first because the docs suggest you put a 48x48 icon in that folder. Since you've provided that already, there's no reason why the application would ever have to look in the drawable/ folder for a default image. Even if it did, it would not be beneficial since you've already provided an icon of the same size.
If you've provided even just one size of a particular drawable, your app shouldn't crash on any devices, even if the size you provided is very wrong. The image will just look bad in that case, because the system will load the single image you have provided. So, if you've got the image in the drawable-*dpi folders, you won't need a copy in drawable/.
TL;DR
No, you won't need to put a 48x48 copy of ic_launcher.png in the drawable folder if you've already got one in drawable-mdpi/, because the system will choose that one first.