1. 技术文章
  2. Reducing android app (apk) size

Reducing android app (apk) size

由 家住魔仙堡 提交于 2019-11-27 06:33:46
Christopher Rucinski

So, Why do I see that much increase in my app size, Can it be minimized?

Almost solely because of your res folder images! You should have around 4 copies of each image in the drawable-mdpi, -hdpi, xhdpi folders. The only difference is that theu are all different sizes.

Is it safer to delete them, & deleting them can help to decrease apk size?

Chances are there aren't multiple copies of those jar files! Just one copy with links to it!

Proguard

Yes, what you said was right about Proguard. However, realize that you are talking about text files here. They are really small. I mean really small in size (kilobyte-wise). Your problem is something in the megabyte (MB) size. That is images!!!!

Repeat. That is images!!!!

Enabling proguard will save a little bit size-wise.

Also you can mention in your answer anything that is missing which you feel should be shared?

Yes, these are all more important in your case. Please read and apply these. Good luck!

If a user finds your app helpful, then they won't uninstall it; however, there are several things you can do

  • Can you move images to the web and async them into your app?
  • Make sure your files are completely compressed as much as possible. Use pngquant or tinypng.
  • Check for any repetition in the images. You might be able to use 9-patch for it.
  • You might be able to make your own drawables for certain images.

  • Allow users to move data to an SD card.

  • [EDIT] After the app has been in the Play Store for a while, check the Developer Console and see which screen size/density is used the least. Remove that drawable folder from your app! This could reduce the size a good amount! But, check my edit below for the cons of this approach!!

  • [EDIT 2] In Windows Explorer, check the folder size for your whole res folder, and the whole java folder. If your java folder's size is small, then all your effor to reduce APK size should be what I state above.

You might want to show a few of the images, as that would allow us to see what you are dealing with

EDIT

@Ashwin N Bhanushali Has a great answer here for the part of the question I did not answer, but he basically told you that there was nothing you could really do except what I said, plus an idea or 2 more.

I did have another idea that was based on one of his ideas that would be even better, because Android Studio does not include the drawable-ldpi folder in the project anymore. So it would only be helpful if you use Eclipse, mine expands

  1. Release the APK into the Google Play Store after making the recommended fixes
  2. After some time has passed -- a week, a month, etc -- you can check the stats of your application in the Google Play Developer Console.
  3. Look for the screen size buckets(drawable-mdpi, -hdpi, -xhdpi, -xxhdpi) that are used the least! You could remove those buckets from your app altogether!

This works because pictures take up way more bytes than text files. And all those drawables have the same images in them (just different sizes). Removing the images from less used buckets can save a lot of space!!

Take note that removing those buckets from your app will mean that your app will have to do more work on those phones that use the removed buckets. The app might be slower for those users; however, the app size can be reduced more.

EDIT 2

Text files take up almost nothing. Take a look in the file system for your project!

In the picture below. Check the size of...

  • the java folder
  • the res folder

In your case, you will see that the java folder is probably really small in size (10 through a few hundred KBs); however, you will see that the res folder is really large in size (several MBs!).

That means that any compression, or reduction in your code base will be very small and not worth it!!

Therefore the best way to reduce your APK size is to follow my instructions above!

Edit 3

Here is a test that you can do right away and see the absolute maximum (plus more) that tools like Proguard, and AndroidUnusedResources.jar will reduce the size of the APK file!

What you have to do is remove ALL code from your project except for the class declarations. Do the same for Abstract classes, Interfaces, Enums, etc... Your project structure should stay the same, and you should not be using any external libraries at all then.

  1. So you will have something like this for all of your classes...

    public class CustomClass {

    private String variable; // List of variables

    public CustomClass() { ... } // List of constructors

    public getVariable() { ... } // List of Assessors

    public setVariable(String val) { ... } // List of Mutators

    private String helperMethods() { ... } // List of helper and other methods

}

  2. You should remove all the code inside of the classes, interfaces, enums, etc to look like the following; however, leave all your images alone!! ...

    public CustomClass {

    // Everything is removed!! No libraries used, nothing. Unless certain classes 
    //     require some methods like Activity. Those methods should be empty though!

}

  3. Now compile and build your project.

  4. Check the new APK size to your current APK.

    • This will be the smallest possible compressed size file you can achieve with your code. Yes, your program wont do anything, but that is besides the point. You care about size here, and this is ONLY a test.

  5. Install the app on your phone, and check the new app size to your current app size

    • This will be the smallest possible uncompressed size file your can achieve with your code. Yes, your program wont do anything, this is just a test.

If you notice that the 2 apps are still around the same size, then spending all your time with Proguard and AndroidUnusedResources.jar is meaningless at this stage. This is a test to see where you would spend your personal resources in app size reduction.

So, Why do I see that much increase in my app size, Can it be minimized ?

The .apk-file

An .apk-file is not magical at all. It's just a bundle of files which represent the content of an Android application. If you open it in a archive-tool (like 7Zip), you can browser and extract it's contents.

Now this apk file is extracted during installation hence there is increase in the size of the App.

Some more detail regarding compilation

What happens to the .java-files?

Well, first they are normally compiled by an installed JDK implementation. After they are compiled (to .class-files), the dx-tool from the Android SDK then cross-compiles those "normal" java-classes into Dalvik-Bytecode.

This "special" java-code is then interpreted by the DVM (Dalvik Virtual Machine), which is based on the opensource JRE-implementation Apache Harmony.

What happens to the resources i put into the /asset-directory?

Android offers the /assets-directory to add some binary raw-files (e.g. a SQLite Database). Files which are put into this directory are not compiled or optimized.

If you put your files into this directory, this is the kind of behavior you would expect from Android.

What happens to the resources i put into the /res/raw-directory?

Like the /assets-directory, you can also put binary (or other) raw-files in here (e.g. HTML-files for the Help-page). These files are compiled/optimized (if possible).

What happens to the Manifest and the other XML-files?

The Android-Manifest and also the other XML-files (Layouts, Strings, etc.) are stored and "compiled" into a binary XML-format. This is a speed-optimization.

So you got the answer why app size is increased after installation.

Now Is it safer to delete them(Android Libraries), & deleting them can help to decrease apk size?

You can remove google-play-services.jar since it is required only in development environment it's not required in runtime environment.Prompt user to install it from the play store.

Coming to Proguard :: It will remove the unused java classes and will do the code obfuscation.It will not remove unused resources like layout xmls,drawables etc. So my opinion is to run the tool to remove unused resources.

Below are some tips to reduce the size.

You can remove drawable-ldpi folder if you are using it.Since there are no more devices with ldpi screen resolution.

Reduce the use of image drawables(i.e .png or jpg files).Use xml drawables and 9-patch drawables.

Remove any debug info related code.

Avoid code duplication.Follow the principal of Don't Repeat yourself.

I think this is enough to reduce app size in your case.

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

For those of you doing much smaller projects, consider removing all the app-compat libraries. You may be better off making multiple versions of your app for specific versions of the API. I've seen a 47Kbyte app balloon to 3Mbytes just by adding compatibility libraries.

Summary: to save space, avoid unnecessary libraries, even ones provided by Google (and included in most templates!).

Try enabling http://developer.android.com/tools/help/proguard.html , even without obfuscation. It will remove unused Java code from your dependencies. See if you have unneeded dependencies - JARs that you've added but aren't using Check your resources for large images or other files. You may want to change their format or resolution, or remove them if they're not in use.

Generally, in ProGuard, you can use the following to shrink your APK (this is in your module's build.gradle file):

...

android {

    ...

    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }

    ...

 }
 ...

Specifically, look at minifyEnabled true and shrinkResources true:

minifyEnabled is responsible for obfuscating and shrinking your code files (e.g. Java). It is the main feature of ProGuard, and helps to shrink your APK as well as making it difficult to reverse engineer.

shrinkResources is used to remove unused resource files (such as images and other assets). For example, if you are compiling with an Android library, but you are not using some images in that Android library, they will not be included in the final build. There is a good Android Developers video about it here.

Ka Developer

Now you can also use vector drawable in your app to remove multiple drawables for different screen sizes and reduce APK size. see: https://stackoverflow.com/a/33984100/5305331

Deep Shah

It is one option that you compress all your PNGs for that you can go to https://tinypng.com/ .

After that remove unnecessary library imports for example it is not require to import support library v4 if you already imported v7 for appcompat.

And finally after completion of signing procedure of apk use zipalign tool that is shipped with android-sdk for more details refer http://developer.android.com/tools/help/zipalign.html.

That's all i know.

First of all look in to your drawables.

  1. If you are using a PSD to get the images for the app, those images might not be optimized for web and devices. You Photoshops "Save for Web and Devices" to optimize the images. You can reduce lot of kbs from this.
  2. Next, see if you can replace images with XML drawables. For example, buttons and background can be done using XML

ProGuard by default applies its shrinking, optimization, and obfuscation -- that's its main purpose. You do have to enable it in your Android build, by editing the documented ProGuard line in your project.properties. It enables ProGuard (with or without optimization) for release builds with Ant and Eclipse. With Ant, you'll see ProGuard output in the build log.

See the Android documentation > Tools > ProGuard.

You should then check your processed application. You may need additional -keep options, e.g. possibly for Google Play Services. The less you can keep, the smaller your application will be.

The reason you see the increased file size is that APK's are compressed files. Use of Proguard can help - here's a good resource:

http://developer.sonymobile.com/2012/01/31/tips-for-reducing-apk-file-size/

However, I can assure you that you can get millions of downloads without being file-size sensitive. Both from my personal experience but also from looking at Google Play. There are thousands of apps with millions of downloads where the file size greatly exceeds 2MB. In fact, there are many that are around 20MB. In other words, do what you can to keep it small, but don't worry that it will impact use or downloads.

In most of the cases app size is propotional to the resource file(images and other stuff) that you use to create an application.Always consider the following.

  • Try using minimal images.(In most cases ,there is not need to add images in the Ldpi folder) .
  • Use vector images instead of putting images for all screen resolutions .One way is to use SVG ,9 patch
  • Try to use xml drawable to create generic images like square,rectangle circle,borders etc instead of .png images Try some image compression techniques.
  • Try fetching large images from Api rather than putting it in the res folder.(Download only when needed).

Library imports

  • Try to remove unwanted libraries while creating a build for appstore.
  • If you need a particular functionality in a alibrary then try to extract the required class files and use it rather than importing the whole library jar.
  • Clean your class by removing unused import (although it won't have much effect on size but it will make things more simple and straight).In eclipe select the src folder->rightclick->source->organize imports

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.

user2642486

Re-compress APK/ZIP as high, it will save 30% more then normal apk build by Android SDK, useful if large number of text files but not if large number of images.

You can try another answers and they are very good but there is another small trick for reducing massive amount of apk size.
We use many libraries in our projects. some of them developed in Native language ( c ) and some of them developed for a specific version of architecture.

We have some architecture :

  • armeabi : Uncommon
  • armeabi-v7a : Common
  • arm64-v8a : Common
  • mips : Rare
  • mips64 : Rare
  • x86 : Common
  • x86_64 : Uncommon

You can filter target architectures and remove useless options. for example :

buildTypes {
    debug {
        ...
    }
    release {
        ...
        ndk {
            abiFilters "arm64-v8a", "armeabi-v7a", "x86"
        }
    }
}

Check my blog Different ways to reduce apk size

Main Points are :

  • android.enableR8=true // enable New R8 Code Shrinker
  • minifyEnabled true && Add Proguard Rules
  • Examine Your APK Using Android Studio’s APK Analyzer
  • Enable Resource Shrinking
  • Convert Your PNGs, JPEGs, and BMPs Into WebP
  • Avoid enumerations and use @IntDef annotation
  • Use aaptOptions { cruncherEnabled = false } to compress images
  • Use Remove Unused Resources android studio built-in function to remove all the unused resources in the application
  • Use Code Cleanup android studio built-in function to remove

Note: Go enable it! (*just double and triple check everything works afterwards)

标签
java
android
jar
apk
proguard
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!