I have a bit of a weird bug/issue with one of the apps I'm working on. On some devices running Android 6, the app icon is smaller in comparison to the rest of the icons from other apps.(See attachment) Any idea why?
I've checked and the ic_launcher have the right resolution - according to this: Android - Launcher Icon Size
Probably also worth mentioning that the icons were generated using the icon generator within Android Studio.
Thanks!
Drawables and mipmaps are nearly identical even mipmaps are mostly used for launcher icons and drawables for other things. The suffixes (e.g., -mdpi, -hdpi) are filters,
indicating under what circumstances the images stored in those directories should
be used. Specifically, -ldpi indicates images that should be used on devices with
low-density screens (around 120 dots-per-inch, or “dpi”). The -mdpi suffix indicates resources for medium-density screens (around 160dpi), -hdpi indicates resources for high-density screens (around 240dpi) and so on.
Android Studio offers an Image Asset Wizard. This wizard is designed to take a
starter image and give you icons, in a variety of densities.Android will calculate density of the screen on which app is installed and by that it will take the correct icon. If there is non than Android will take the nearest one. You can find more about mipmaps and drawables on official developer site or any relevant book about android programming like The Busy Coder's Guide to Android Development.
There is Android Asset Studio which you can use in Chrome browser to generate your icons: https://romannurik.github.io/AndroidAssetStudio/
it seems that the problem was the selected shape when generating the icon with the Images Asset tool in Android Studio. Square is selected by default. Selecting none fixed the issue.
Related
Switched my eclipse project to Android studio. I was maintaining resources under drawable-mdpi folder only. Now in studio the preview of XML loads images correctly. However when I run the app in a device with resolution higher than mdpi the app crashes, shows error inflating binary XML.
After a long analysis I found the issue that the device was trying to load images from its corresponding density folder which is not available. So I created the folder drawable-xhdpi and put images in that folder. Now the app works fine.
Why android studio can't pick image from other density drawable folder and resize which is possible by eclipse. I can't maintain 5 different drawable folders because there are lots of images.
you have to add "drawable-hdpi" resource directory and paste all the hdpi resources there because currently 70% android devices supports hdpi resolution images.
if you only maintain the hdpi, then it is also ok.
android manages all remaining resouces from hdpi resouce directory.
Android application resource directories provide different layout designs for different screen sizes and different drawables. These different drawables are used by android to support a major range of all the android devices present out there. It's a standard practice to put your resources considering these densities. Coming back to your query:
Why android studio can't pick image from other density drawable folder and resize which is possible by eclipse. I can't maintain 5 different drawable folders because there are lots of images.
For your case,In order to maintain this you could create a drawable with nodpi and put your all resources there. nodpi focus resources for all densities.Your resources should be density-independent resources. The system does not scale resources tagged with this qualifier, regardless of the current screen's density.
Hope this will clear your doubts, for more insight you can also look this.
you don't need to add all images to each difference size folder but depending the size of the image you might need to add images to different folders.
simple example is this can occour once you add high res/size images in normal drawble folder
Skipped 100 frames! The application may be doing too much work on its main thread.
This might not crash your app but will make it's performance down.
and
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 : https://developer.android.com/guide/topics/resources/providing-resources.html#AlternativeResources
Do we need to add all images with different dpi to Android Apps
I was trying to add some images to my project in Android Studio however I noticed that I only had the drawable folder, neither of other (drawable-hdpi etc.) folders were there.
So I decided to put them by hand, just created the folders with appropriate names and placed the images:
However It still kept giving this error which I couldn't handle. Why this error occurs and how to solve it?
Thank you.
drawable-* folders should be under res and not under res/drawable.
Different home screen launcher apps on different devices show app launcher icons at various resolutions. When app resource optimization techniques remove resources for unused screen densities, launcher icons can wind up looking fuzzy because the launcher app has to upscale a lower-resolution icon for display. To avoid these display issues, apps should use the mipmap/ resource folders for launcher icons. The Android system preserves these resources regardless of density stripping, and ensures that launcher apps can pick icons with the best resolution for display.
Make sure launcher apps show a high-resolution icon for your app by moving all densities of your launcher icons to density-specific res/mipmap/ folders (for example res/mipmap-mdpi/ and res/mipmap-xxxhdpi/). The mipmap/ folders replace the drawable/ folders for launcher icons. For xxhpdi launcher icons, be sure to add the higher resolution xxxhdpi versions of the icons to enhance the visual experience of the icons on higher resolution devices.
Note: Even if you build a single APK for all devices, it is still best practice to move your launcher icons to the mipmap/ folders.
check here
and here too.
Say, I have an ImageView with both sizes set to wrap_content, and it has some image: android:src="#drawable/xyz".
If this image appears only in xxxhdpi folder, then everything is fine. However, if it appears in any of the other drawable directories (xxhdpi, xhdpi, hdpi, mdpi, or even sw320dp), then it doesn't use the image from xxxhdpi and, as a result, the image is blurred. (it's not easy to notice, but I can notice this and I don't think QHD displays make any sense if their full resolution is not used)
Is it possible to solve this issue without resorting to multiple APKs?
More precisely, this is LG D856 phone (dual SIM), with Android 4.4.2.
update
This is weird, but if I create project in Android Studio instead of this tool for coding for Android in Scala, then there's no such issue…
update 2
APK file: http://dropbox.com/s/lqdj9w7iimh2gj9/magicgoose-example-debug.apk?dl=0
Source code: http://dropbox.com/s/cs4pngpkvkoe5q2/dpi-example-src.zip?dl=0
Source can be built using SBT (scala build tool)
I'm using this plugin: https://github.com/pfn/android-sdk-plugin
read here:
http://developer.android.com/design/style/iconography.html
Provide an xxx-high-density launcher icon
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.
I know for some cases you really wish it used the xxx but what I understand for this text is: "Android only uses xxx for the launcher icon and nothing more." So I believe you'll have to find some work around (e.g. set a bigger PNG and scale it down on the ImageView, or mipmaps) until Android as a platform uses the triple X everywhere.
The problem was in that the plugin did set target API level to 1 by default. When I set it explicitly to 21, the problem is gone.
I have an Android app that I would like to display high quality images with. However there are many different screen sizes and ratios. I know there are filters to show apps in Market only for devices with small/medium/large screens.
If I put images of both sizes in 1 app it will double the size of the app, right?
Is it a good practice to make multiple versions for different screen sizes?
I would like to make 1 app in 3 versions for such devices:
medium screen mdpi
medium screen hdpi + large screen mdpi
large (tablets)
If it's possible to do it how can I specify them in manifests? Or is it somewhere in market?
Android has a built-in mechanism for having resources designed for different screen sizes and pixel densities. It's called resource directory qualifiers, and you can read all about it here.
For example, for small screen sizes, you could create a specific layout file and place it in the res/layout-small directory. For a larger screen, you could create a layout file with the same name and place it in the res/layout-large (or res/layout-xlarge) directory.
For pixel density, you could create a small version of your image resources and place them in the res/drawable-ldpi directory (lower pixel densities). And for higher pixel densities, you could create alternate versions and place them in the res/drawable-hdpi directory.
I'd encourage you to read the page on Supporting Multiple Screens, and let Android help you out with its built-in mechanisms. Creating three separate copies of your app is harder for you to maintain, and it confuses potential users (most of whom probably neither know nor care about "pixel densities"). What's to stop them from downloading the wrong version of your app, and getting a lousy experience because of it?
No one seems to be addressing the file size issue you're really asking about, so I'll try.
You should package your high quality images as a set of separate downloads, one for each type of device you plan to support. This makes your base app small, and ensures the end user's disk space is only filled by images it needs.
I've not done this myself, but hopefully the idea will send you on the right search path. I imagine you design the separate download as either resources on your own server, or another set of apps in the market (i.e. "MyApp Image Pack HDPI", "... MDPI", etc.).
As Donut mentions above android has excellent documentation for this here, here, here and here.
Note that all Manifest file changes and how to create one binary that will support different screen sizes, different densities AND different SDK's are at android website. But it requires careful planning and testing to do so.
The best way is to have ALL device configurations (listed here, including the Samsung Galaxy Tab simulater (large screen, hdpi) available here) in your development environment and test your app on them.
You have to create different .apk for each version and define this in your application's manifest file.use this link
http://developer.android.com/guide/practices/screens-distribution.html
On the topic of included standard icons the Android documentation mentions that:
Shown below are standard menu icons
that are used in the Android system.
Because these resources can change
between platform versions, you should
not reference the system's copy of the
resources. If you want use any icons
or other internal drawable resources,
you should store a local copy of those
icons or drawables in your application
resources, then reference the local
copy from your application code. In
that way, you can maintain control
over the appearance of your icons,
even if the system's copy changes.
Note that the list below is not
intended to be complete.
In my application I'm using such standard icons such as "ic_menu_sort_alphabetically" and thus I've tried to find these icons, so that I can include them in my application.
However, in "android-sdk/platforms/android-8/android.jar" I only find the icons in drawable-mdpi and in drawable-hdpi - there is neither a default drawable folder with icons, nor a drawable-ldpi folder with low-resolution versions of these icons. However, such a low-resolution version would be required to provide native versions on ldpi devices such as the HTC Wildfire.
Are there any "official" versions of the Android icons scaled at ldpi? While it's likely that the ldpi versions are stored somewhere on my HTC Wildfire device, I assume that they are copyrighted by HTC and not under the same open-source license as the icons in the Android distribution.
If you can't find the pre-scaled images, you can just open the mdpi in Photoshop or GIMP and resize them by 75% to make the ldpi icons. To make hdpi resize the mdpi image by 150%.