I'm gonna release my app, it's a 1.2Mb apk that includes about 120 icons in 4 different formats (ldpi, mdpi, hdpi, x-hdpi).
If I add xx-dpi and xxx-hdpi icons the apk grows bigger and loading time increases.
There are many entry-level devices out there with really loooow memory and I'd like my app to run everywhere.
Do I really need to add xx-hdpi?
And is there a real device that requires xxx-hdpi?
You shouldn't really need xxxhdpi. It was only introduced because of the way that launcher icons are scaled on the nexus 5's launcher
Edit
Back when I answered in Jan 2014, the Nexus 5 was the only device using xxxhdpi. Now many devices including the Nexus 6 and LG G3 use it. So it would be a good idea to include it in your app.
We had to add xxxhdpi to our app for the Nexus 6, LG G3, and Samsung Galaxy Note 4. There will be more xxxdhpi devices in the future.
You do not need xxxhpdi for most of your images. You only need xxxhdpi for your launcher icon. Please see http://developer.android.com/guide/practices/screens_support.html
You should not use the xxxhdpi qualifier for UI elements other than the launcher icon.
It's pretty clear in the above quote. In the example folder layout they give, they show all the densities for the res/drawable folders up to -xxhdpi, but then they show the res/mipmap folders up to -xxxhdpi. Here are more quotes:
xxxhdpi Resources for extra-extra-extra-high-density (xxxhdpi) uses (~640dpi). Use this for the launcher icon only, see note above.
The mipmap-xxxhdpi qualifier is necessary only to provide a launcher icon that can appear larger than usual on an xxhdpi device. You do not need to provide xxxhdpi assets for all your app's images.
You don't need ldpi, because Android downsizes hdpi to ldpi.
From https://developer.android.com/design/style/iconography.html
Note: Android also supports low-density (LDPI) screens, but you normally don't need to create custom assets at this size because Android effectively down-scales your HDPI assets by 1/2 to match the expected size.
From Android iconography documentation itself:
Some devices scale-up the launcher icon by as much as 25%. For example, if your highest density launcher icon image is already extra-extra-high density, the scaling process will make it appear less crisp. So you should provide a higher density launcher icon in the drawable-xxxhdpi directory, which the system uses instead of scaling up a smaller version of the icon.
Note: the drawable-xxxhdpi qualifier is necessary only to provide a launcher icon that can appear larger than usual on an xxhdpi device. You do not need to provide xxxhdpi assets for all your app's images.
more on: http://developer.android.com/design/style/iconography.html
I don't know if there is a device that requires xxx-hdpi, but xx-hdpi is not yet used very often. But the same goes for ldpi, almost no device still requires ldpi. If you just do mdpi, hdpi and xhdpi, it will be just fine. If a device requires something bigger or smaller android just scales it to the right size.
Heres what Android says about this:
Provide different bitmap drawables for different screen densities
By default, Android scales your bitmap drawables (.png, .jpg, and .gif
files) and Nine-Patch drawables (.9.png files) so that they render at
the appropriate physical size on each device. For example, if your
application provides bitmap drawables only for the baseline, medium
screen density (mdpi), then the system scales them up when on a
high-density screen, and scales them down when on a low-density
screen. This scaling can cause artifacts in the bitmaps. To ensure
your bitmaps look their best, you should include alternative versions
at different resolutions for different screen densities. The
configuration qualifiers you can use for density-specific resources
are ldpi (low), mdpi (medium), hdpi (high), and xhdpi (extra high).
For example, bitmaps for high-density screens should go in
drawable-hdpi/.
You can find the documentation here:
https://developer.android.com/guide/practices/screens_support.html
Hope this helps
I think you should focus on the most popular screen densities, which are hdpi, xhdpi, and xxhdpi. See this link for the current worldwide average distribution of each density.
Forget Everything & make it Simple !
Just store highest resolution images in only one folder. Either in drawable-hdpi, & delete other images from the rest drawable folders.
I have tested it in various devices & it works like a charm...
Related
I have one image that is in all folder except drawable-ldpi folder. Then if i will run my project in ldpi devices then from which folder it will try to find that image? or my app will simply get crash? I am not having this image in my drawable folder,too.
Test case i performed using mdpi device --
Placed image in drawable-xxxhdpi folder only, worked fine.
Placed image in drawable-ldpi folder only, worked fine.
Came to conclusion it perform both scale up and scale down
Regards
It is not required to have images for all the densities, only one is enough. The system will scale it up/down when needed. So the best approach is to have images for the highest density supported (xhdpi or xxhdpi).
It will scale but you might run into problems when a phone with a ldpi tries to load xhdpi or xxhdpi images.
Google's recommended that it is useful when you are creating different images for each resolution and not just resizing it.
And also in present when Eclipse creates launcher icons, it only creates them for mdpi, hdpi, xhdpi, and xxhdpi. Based on that creating ldpi icon is not necessary and that mdpi will be scaled down automatically.
In your case it will try to find image in mdpi folder.
Dont worry, FYI ldpi device is closed before some months and now no any new ldpi device will come in market. But if any user will install your app in ldpi device then it will find closest image as compare to ldpi and will show it.
But that image must be in any of the folder.
If the user is using a device with a low density screen, and a ldpi resource is not found, the resource with the closest density is used and scaled down.
By the way, I wouldn't even bother with mdpi, let alone ldpi.
Your app will not crash until you have the named image in at least one of drawable folders. System will show the closest density image.
I am designing an android app for a client. Following the guidelines of Android UI design I have sliced all the icons and images in the following dpi's - xxhdpi, xhdpi, hdpi, mdpi, ldpi.
While the android design guide says they have released xxxhdpi also. Is it necessary to include files with 640 dpi(xxxhdpi) with my app?
Does the app loading time depends on this?
As per Developer site
Some devices scale-up the launcher icon by as much as 25%. For example, if your highest density launcher icon image is already extra-extra-high density, the scaling process will make it appear less crisp. So you should provide a higher density launcher icon in the drawable-xxxhdpi directory, which the system uses instead of scaling up a smaller version of the icon.
Note: the drawable-xxxhdpi qualifier is necessary only to provide a launcher icon that can appear larger than usual on an xxhdpi device. You do not need to provide xxxhdpi assets for all your app's images.
Check this link for more details http://developer.android.com/design/style/iconography.html
As you know Android applications have different DPIs and also in the Android applications we can add drawables with diffrent DPIs in diffrent ldpi, mdpi, hdpi and xhdpi folders.
The question is that when we want to support all DPIs we should add the icons with all different sizes or just with the biggest one?
I mean for example suppose that I have one action bar item with icon. Whether I should add the icon of this action bar item with 24x24(in drawable-mdpi folder),36x36 (in drawble-hdpi folder),48x48 (in drawable-xhdpi folder),.....
Or I just need to add one icon with size 96x96 in xxxhdpi folder and android will set the icon for other DPIs with good quality?
TLDR see the bold below
Different density folders were added later on for Android which means that...
If you wanted to be lazy and just add one asset the best choice would probably be the HDPI asset if your min app target < 8 and XHDPI if its >= 8. This is because the system will scale the resource up and down, but you would still want to start off with the highest resolution possible.
If you want to have complete control over how the assets are scaled then you can by all means provide your own for all / some of the densitys. In practise I generally provide HDPI / XHDPI as above and give all the resource buckets for things like logos / AB icons / App icons etc. I generally find the auto scaling to be pretty good and work for most situations, but will occasionally have to supply and extra LD/MD asset if its a small asset / contains small text etc. Plus if i duplicated all assets for things like XXXHDPI I would get pretty good apk bloat.
You can also use IDEs built in tools to add a single asset for many densitys at once. In Android Studio 0.6 this is File->New->Image Asset and a wizard will appear.
I have never noticed or heard of any perfomance impact of allowing Android to scale assets automatically - presumably this is done in hardware.
It may not look great when auto scaling down to LDPI say so you can optionally provide your own scaled assets for all other densities.
Taken from the link below
ldpi: Low-density screens; approximately 120dpi.
mdpi: Medium-density (on traditional HVGA) screens; approximately 160dpi.
hdpi: High-density screens; approximately 240dpi.
xhdpi: Extra high-density screens; approximately 320dpi. Added in API Level 8
nodpi: This can be used for bitmap resources that you do not want to be scaled to match the device density.
tvdpi: Screens somewhere between mdpi and hdpi; approximately 213dpi. This is not considered a "primary" density group. It is mostly intended for televisions and most apps shouldn't need it—providing mdpi and hdpi resources is sufficient for most apps and the system will scale them as appropriate. This qualifier was introduced with API level 13.
List taken from this dev link for more info.
This is the approach I have used on many apps in my professional career including ones for Google & the BBC and not had issues.
So I am learning how to program android apps, and have just barely started. Looking through the developers page I followed a tutorial to add a search bar in the menu. However, it asked to put an image in the res/drawable folder. Upon seeing all these options I just placed it in the first folder, drawable-hdpi, and the app worked. I was just wondering if anyone could explain what the difference in each folder is, and if the icon is placed in the correct folder (even if the app still runs). Whats the most optimal solution?
http://imgur.com/t2r6fS2
Android Tutorial: http://developer.android.com/training/basics/actionbar/adding-buttons.html
Edit: Wow! Thanks for all the responses. You guys are fantastic. I'll mark an answer as soon as it will let me.
The folder names need to be :
/drawable-ldpi For low density screens
/drawable-mdpi For medium density screens
/drawable-hdpi For high resolution screens
/drawable-xhdpi For extra high resolution screens
/drawable should be reserved for assets that you don't either care which device or for xml drawable assets
Then on top of that you can provide different resources based on configuration by using config qualifiers, you can read all about it here http://developer.android.com/guide/topics/resources/providing-resources.html
for instance, you can have high resolution assets for landscape with a folder
/drawable-land-hdpi
Hope that helps
Android devices comes with different screen sizes and different resolutions. To support your application's images with different device's screen size you need to put your image in their respective folders. Following are the screen size supported by Android devices
LDPI ( deprecated )
MDPI : 48x48 Pixel
HDPI : 72x72 Pixel
XHDPI : 96x96 Pixel
XXHDPI : 144x144 Pixel
TVDPI
You can create such sizes images by helping of this site Android Asset Studio
These different folders are for different screen sizes. Here is a link to the android notes, http://developer.android.com/guide/practices/screens_support.html .
In short the ldpi is for low resolution screens, mdpi for medium resolution and so on.
Android different Screen size with different resolutions:
- drawable-ldpi (it need resolution or ppi is ~120)
- drawable-mdpi (it need resolution or ppi is ~160)
- drawable-hdpi (it need resolution or ppi is ~240)
- drawable-xhdpi (it need resolution or ppi is ~320)
If you create big images but less ppi then it will go in this manner. So be aware about this.
this may help you ....
check out the answer in below link
What is the difference between "px", "dp", "dip" and "sp" on Android?
I have an Android app containing about 150 icons for each screen resolution.
If I put all the icons in all 5 major resolutions (ldpi, mdpi, hdpi, xhdpi, xxhdpi), then it will make the total number of icons to 750.
This has several drawbacks:
Big APK size
Slow build process when using dexguard with ant build script. It
does some processing on the images that take some time.
Alternatively I can put icons only in some of the resolutions. For instance ldpi devices are only 10% of the market now, and somewhere in Android official doc they say that Android can efficiently scale down 50% from hdpi icons to ldpi.
Now, if I chose to go this way and not provide ldpi icons, what will be the impact of resizing the icons from hdpi to ldpi at runtime on the Android device? If it needs to resize 150 icons it can take some time, especialy since ldpi devices are likely to have slower CPU.
At which stage does the resizing happen on Android devices: at install time? At first app launch time? At each launch?
Thank you for your suggestions!
When you decompile Google's own APKs they are not using ldpi at all for a time. And they are using xxhdpi only for launcher icon of the applications. xxhdpi icons especially makes the APK sizes bigger.
The resizing of the icons probably done on runtime at each launch.
If the images are used at the layout you can use the xxhdpi images and then you can generate the xhdpi, hdpi, mdpi and ldpi at run time.
Get the Image from the xxhdpi.
scale it to the needed resolution.
use it in your layout.
write it in the disk.
try this to generate thumb at runtime.
Android will nicely* scale down your drawables by a difference of up to 2 density buckets. It looks like crap if you try to do more than 2 buckets (ie. more than a factor of 2). So you should provide every third bucket - currently xxxhdpi and hdpi only.
*Unless you have pixel art in your drawables (but don't do that), where bilinear interpolation won't be acceptable. Then you should pick a minimum supported bucket and provide everything above that.