I am making a book app with pdf files in the assets folder. All files are 10-20mb after compressing. How can I keep the size of the app small?
It's 500+mb currently.
Android studio provides a handful tool: APK Analyser APK Analyser will tear down your application and let you know which component in your .apk file is taking the larger amount of space? Let’s have a look in Anti-Theft screen lock apk file without any optimization applied.
From the apk analyser output, you can see that the application raw size is about 3.1MB. After applying play store compressions, the application size is roughly 2.5 MB.
As you can see from the screenshot, there are main 3 folders that are consuming most of the application size.
classes.dex — This is the dex file which contains all the byte code files of your java code that will run on your DVM or ART.
res — This folder includes all the files under your res folder. Most of the time this will contain all the images, icons and raw files, menu files, and layouts.
resources.arsc — This file holds all the value resources. This file contains all the data you have under your different value folders. This resource contains strings, dimensions, styles, integers, ids etc.
So, now you know what an APK is made of. Let’s see, how can we decrease the application size by optimising one by one component.
Reduce classes.dex:
As we discussed, this contains all the java code. While you build your application, gradle will combine all of your .class files from all the modules and convert those .class files to .dex files and combine them in single classes.dex file.
Single classes.dex file can accommodate, approximately 64K methods. If you exceed this limit, you have to enable multidexing in your project. Which will create another classes1.dex file to include all remaining methods. Thus the number of classes.dex file depends on the number of methods you have.
As you can see currently “Anti-Theft Screen Lock” contains 4392 classes and 29897 methods. This result is without applying proguard. You have two default proguard file you can apply.
- proguard-android-optimize.txt
- proguard-android.txt
As the name suggests “proguard-android-optimize.txt” is the more aggressive progurard configuration. We used this as the default proguard configuration. You can add you custom proguard configurations in proguard-rules.pro file in your /app directory.
Compression Gist 1
By setting minifyEnabled to true (In the Compression Gist 1), you are telling proguard to remove all the unused methods, instructions and slim down the classes.dex file.
Here is the result from minify enabled APK,
As you can see by enabling the proguard in every module of our project we can we are able to reduce the classes.dex file size almost by 50%. Also, you can see method count decreased from 29897 to 15168 (almost 50%).
Size decreased from 3.1 MB to 1.98MB. (~50% decrease)
Reduce res:
The second largest component in your apk size is your res folder, which contains all the images, raw files, and XML. You cannot add/remove/modify your XML, as they are containing your layouts. But we can decrease the image files.
“shrinkResources” attribute will remove all the resources, those are not used anywhere in the project. Enable this in your build.gradle file by adding below line:
Compression Gist 2
“resConfigs” attribute will remove all the other localized resources while building the application. In our case, “Anti-Theft Screen Lock” only supports the English language. While all the support libraries may have localized folders for other languages. Which we don’t need. So, add following line to allow only English resources to be added in APK file.
Compression Gist 3
Android Studio 2.3, and you application minimum version is 18 or above, you should use webp instead of png. webp images are having less size than png files and also it retains the original image quality. More to that webp images are natively supported in Android. So you can load webp images in ImageView same as other raster images. So, you don’t have to change your layouts.
You can select drawable and mipmap folders from you project, right click and select convert to webp. This will open below configuration dialog.
Press ok and it will convert all the png images to webp format one-by-one. If the webp image is having the larger size than png, Android Studio will automatically skip that file.
Let’s see the final result:
The res folder size decrease from 710KB to 597KB.
By applying the above simple tricks the application size decreases from 3.19 MB to 1.89 MB.
Happy Coding 😊
Very confused. I just converted a lot of drawables in my res folder to the lossless WebP format. As I did it, Android Studio told me I saved 6mb, however I just build an production-release apk, one for the branch with WebP images and one with everything still as PNG, the difference is negligible. The PNG apk size is 23.2MB, the WebP apk size is 21.3.
I ran the apk analyzer tool, and I can see that the big difference is my res folder is now 7MB smaller, yet that wasn't translated to the apk size?
Here is the apk analyzer results, firstly the old apk (PNGs) Left number is uncompressed, right value is compressed, so what goes out to users in the apk:
Secondly here is the new apk (WebP):
The drawable files are quite clearly smaller, my biggest folder inside res is now 200kb.
Can someone who has played with WebP in Android offer some information on why this didn't work? No other numbers have changed in the apk analyzer.
Edit: Sorry about the small images, view in new tab to see clearer
Solved why it was happened.
I have shrinkResources set to true on my release builds in my build.gradle, so compression was already taking place.
Makes a lot of sense, mistake on my part, totally forgot about it.
You can get better results by using cwebp -near_lossless 40 for your PNG files. I doubt that the automated shrinkResources is able to use near lossless. This may give another 30-40 % compression gain, depending naturally a lot on what kind of graphics you have.
How can I reduce my apk size more efficiently ? I know this is a frequently asked question but I didn't get much help with the resources available.
I have tried "lint" from Android Studio, it removed several resources but the apk size has not shrinked that much.
I have used "PngCrush" to compress png files, but it did not helped much (Only 150Kb reduced). Is there any better solution for reducing png file sizes ?
I am now opting to use ProGuard. Is it safe ? What amount of size will it be able to deduct from my apk ?
My APK size is currently 17 MB, I want to bring it down to less than 10 MB. Are there other solutions available ? Thanks in advance.
Proguard should be the way to go because it removes the unused code as well as renames the variable/method name to something like a,b,c,aa,ab.
What amount can be reduced? It depends. My situation is a 10M apk was reduced to 8M using Proguard.
Is it safe? One of the purpose of Proguard is that it obfuscate the code, making it hard for reverse engineering.
you can use following methods :
1) use proguard : set minifyEnabled true
2) Remove unused resources : set shrinkResources true
3) Remove everything that you are not using
4) If you are using librarires ,try finding the snippet that you are
really using,if you dont find any such version,try fiddling with the
required class directly in your app instead of importing whole library
5) Use vector drawable instead of pngs for your small icons and
drawables
6) Reduce png images clarity to point where it have same
effect to human eye ,while its size is reduced heavily
7) Try generating resources or draws on runtime instead of storing it before
hand
Progaurd is totally safe,make sure you keep a raw backup of ur work before using proguard ,also use proper rules for all libraries and other important resources and code , before you activate proguard.Generally libraries provided default proguard rules for thier libraries
Help!
When I install my app on the phone to test, it is showing up to be a HUGE size, 11.35 MB. It is a very simple app that lets user browse through fun-facts. The only reason I can think of is that there are 14 JPEG files in the drawables which serve as background images of the fun-facts. The average size of these is about 500 KB.
I'd like to trim the size of my app, so as not to use up the precious resources on the user's device. Other than just getting rid of the pictures, are there ways to optimize the size of apk file?
EDIT: The pictures are photos taken by me using the Android phone itself.
Other answers mention shrinking images. You might also consider trying ProGuard to shrink your bytecode. Here's an article on applying ProGuard to an Android app.
I would recommend that you compress the .jpg files as much as possible, this should greatly reduce the size of your .apk file. A tool such as Paint.NET which is free should help you do this. It has great resizing options.
Make sure that your jpg's aren't stored in any higher resolution than necessary. A nice Android phone has a screen resolution of 1920x1200 or 2560x1440 (circa 2015)800 x 480 , so your backgrounds shouldn't contain any more pixels than that (unless your app supports some kind of zooming). Also, are the backgrounds photographs? If not, you may find that using a vector based image format like svg, or one with a dynamic palette like gif, will reduce the file size even more.
UPDATE
With the introduction of Support Library 23.2, now you can replace many of your Image assets with SVG ( w/ or w/o animations) to reduce the apk size further.
ORIGINAL
This could be a late reply but might be helpful for future users.
Refer this link.
To summarise the page, it mentions below key points that will help reduce the apk size in totality:
Use ProGaurd
Remove any debug info you have in the app ( statements such as Log.i()). They can be wrapped in a condition which is only enabled while testing out the application.
Use recommended media formats
Image: PNG orJPG
Audio: AAC
Video: H264 AVC
Compress images using OptiPNG or PNGCrush
Use 9patch to scale images
Find unused resources using this tool and remove them.
Avoid using multiple resources to achieve the same functionality. The resources do not only limit to images but extend to APIs. At times a singular API can provide multiple results instead of using two or three different APIs. Duplicated strings and assets are also a waste of space.
Convert to WebP which will significantly reduce the app size
It reduced the app size of my app which was 40 mb to 25 mb
Steps:
Right click on res
convert to WebP
What it does: It reduces the size to png to WebP format. Quality is also not destroyed
Beyond optimizing images, I also found it useful to verify the Support Libraries you use. I have a relatively simple application targeting platforms with API >=10, still my APK ended up being 2.2M, or after using ProGuard, 1.4M. When I looked into the APK, the code was 1.5M and there were a lot of additional resources included (abc_*) I knew nothing about.
Then I found this: https://developer.android.com/tools/support-library/features.html
Turns out I did not need appcompat-v7, only support-v4, and making this change to my dependencies reduced the APK size to 1.7M (0.9M with ProGuard).
Understandably, the Support Libraries carry a lot of extra (code and resource), so making sure you use only the ones you need might help.
(Even though -0.5M is not significant for a 11M app, I am posting this here because I kept ending up on this page while searching for a solution...)
Use tinypng compress your project's png or
jpg format image files, It can greatly reduce the size of the image
without loss in image quality；
Some images use tinypng compress may distortion, you can convert
these images to webP format, use 智图 or
iSparta can convert other format to webP;
Use Lint check no use resources and delete it;
Four Ways and your app size will become from 11.35 MB to near about 5 MB.
First, check the app components via App Analyzer (an inbuilt feature of Android studio), Simply click on Build on the top and click Analyze APK. It will show you everything what components apk is using.
Enable Proguard
Enable ShrinkResource
resConfigs (Name it, like if your app is in only one language eg English then simply specify resConfigs "en")
Convert all Images from .png or.jpg to webp (Most Important).
Steps to achieve these steps.
1 & 2. For Proguard and ShrinkResource
In gradle, simply add
release {
minifyEnabled true
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
shrinkResources true
}
For resConfigs
defaultConfig {
applicationId "com.goparties.gpuser"
minSdkVersion 19
targetSdkVersion 27
resConfigs "en"
}
TO convert all Images from .png or.jpg to webp
Very easy process: Just right click on the drawable folder(drawable,drawable-hdpi, drawable-xhdpi etc) and click on convertToWebP (last option).
Min SDK version should be 18.
Here we go: Now analyze your app size.
Bingo !!!!!!
One more thing to add on image file size - different algorithms can have a significant effect on the final size. I found that Yahoo's www.smushit.com is a lot more effective (at least for .png) than compressors and codecs I have on my computer right now.
There are two things I can point out from experience.
If you use eclipse to create apk file then the resources are duplicated (atleast it happened in my case), you can try using ant and build.xml to create the apk and compare the size.
Also look into aliasing the resources. The link for it is here.
I think this post would give you a better idea on all the possible methods to use to reduce your apk size by a huge margin.
I will give you an excerpt of the same.
Use only the required libraries from Google Play Services.
Apply ProGuard to your app.
Minify and shrink.
Adopt vector drawables.
Use the android lint.
Split your apk based on the architectures
Adding resConfigs in your gradle files to specify localization languages.
This strips away all other string files that could’ve been added by other libraries in languages you don’t even support.
I know i am late here to answer this question but i reduce my app size using below techniques so i want to share these things with all.
1)- Use WebP images instead of Jpeg images, it will provide huge impact on apk size if you are using multiple images.
2)-Use VectorDrawables if you are using simple small icons in your app.
3)- Use View's tint property in xml to avoid multiple same icons but Different in color.
search DrawableTint and TintableImageview
4)- Use 9-patch images and avoid duplication of image or anything in the app code.
Below are the links to refer to reduce APK size.
https://developer.android.com/topic/performance/reduce-apk-size.html
https://developer.android.com/studio/build/configure-apk-splits.html#configure-split
https://developer.android.com/training/multiple-apks/index.html
WebP image format: provides lossy compression (like JPEG) as well as transparency (like PNG) but can provide better compression than either JPEG or PNG
Convert images to WebP
Along with the above most upvoted answers, I would like to answer with latest tools from Google's Android Studio.
Google recently has introduced the Android App Bundle in which playstore automatically delivered optimized version of apk to end devices.
Now developers just has to generate Signed Bundle, and upload to play store, dev job is done. Don't forget always use SVG images.
Also please have look into Deliver Features On-Demand with Dynamic Features
Here is what you can do for reduce build size by Images (Also can work for iOS)
Here I am sharing the great tool called “OPTIPNG ” (you can download from here )which will help us to reduced the build specially by using Images, It will reduced the Image size for PNGs we are using without degrading quality (Resolution and color) of the image.
Example – If your image size is off 698 KB then It will simpley reduced size to 564 KB
Here is the execution steps for OPTIPNG 0.7.5
1) Terminal -> CD /YourLocal path of OPTIPNG
2) type “./configure”
3) type ”sudo make install”
Intallation should be done now
4) type ” optipng /your image path
You will get result in byte and can also check your size
You could also try http://www.webresizer.com/resizer/ Its an online tool, Did a pretty good job for me.
I used Trimage image compressor for compressing images and reducing the size of apk.It has good compression rate,easy to use,retains the quality of image and is also available in Ubuntu.Beside this i enabled ProGuard and worked on Lint issues to reduce APK size.
Following are the ways to reduce the app size. In detail is explained in the following link.
https://medium.com/#fahimsakri/put-your-apks-on-diet-cc3f40843c84#.m860q8s1u
Proguard
vector drawables
Apk splits
Optimize png images
Remove unused resources
9-patch images
Compress Jpeg images
Remove debug information
Avoid duplications
Use lint extensively
Reuse resource whenever possible
Recommended Media formats
You can reduce apk size by del R.class and replaces the reference to constant.
See this:
https://github.com/mogujie/ThinRPlugin
APK contains a zip file of all the things that your mobile application has including Java class files, resource files among others.
One of the simple ways to make your APK smaller is to reduce the number and size of the resources it contains. In particular, you can remove resources that your app no longer uses, and you can use scalable Drawable objects in place of image files.
Use MinifyEnable true
and ShrinkResources true
MinifyEnabled will reduce your code as it compresses it.
While shrinkResources shrink the resources.
To use ShrinkResources you have to set minifyEnbled true.
There are a few techniques:
Proguard
Unnecessary Resources
Webp images
Signed apk
Android App Bundle
For detailed explanation:
https://stackoverflow.com/a/63988744/13928327
use SVG images instead of jpg in order to reduce the apk size.
put your image files in the database .. so that the users of your app can download it from the database and it will reduce the app size dramatically..