使用NDK时Android应用APK体积过大，如何减小APK大小？

Great question! Even with your APK already sitting at 8MB, there are several focused strategies you can leverage with the NDK to trim down its size further—improving download speeds and user retention along the way. Let’s dive into the most effective methods:

1. Target Only Essential CPU Architectures #

By default, the NDK might generate shared libraries (.so files) for multiple CPU architectures like armeabi-v7a, arm64-v8a, x86, and x86_64. But the vast majority of Android devices run on ARM-based chips.

To cut down on redundant libraries, limit your build to only the architectures your users actually need. For most apps, targeting arm64-v8a (for modern 64-bit devices) and armeabi-v7a (for older 32-bit ARM devices) is sufficient. You can even drop armeabi-v7a if your user base is mostly on newer devices.

Configure this in your app’s build.gradle:

android {
    defaultConfig {
        ndk {
            abiFilters 'arm64-v8a', 'armeabi-v7a'
        }
    }
}

2. Optimize Compiler and Linker Flags #

Tweak your NDK compilation settings to prioritize size over unnecessary performance gains:

• Use the -Os optimization flag: This optimizes for size rather than speed (a small tradeoff that’s often worth it for APK reduction).
• Enable section-based garbage collection: Flags like -ffunction-sections and -fdata-sections mark individual functions and data blocks, while -Wl,--gc-sections tells the linker to strip out any unused sections.

For CMake: #

android {
    defaultConfig {
        externalNativeBuild {
            cmake {
                cppFlags "-Os -ffunction-sections -fdata-sections"
                arguments "-DCMAKE_EXE_LINKER_FLAGS=-Wl,--gc-sections", "-DCMAKE_BUILD_TYPE=Release"
            }
        }
    }
}

For ndk-build: #

Add these lines to your Android.mk:

LOCAL_CFLAGS += -Os -ffunction-sections -fdata-sections
LOCAL_LDFLAGS += -Wl,--gc-sections

And set this in Application.mk:

APP_OPTIM := release

3. Strip Debug Symbols #

Debug symbols are critical for development but add unnecessary bulk to release builds. Ensure they’re stripped out:

• For CMake, setting -DCMAKE_BUILD_TYPE=Release (as shown above) automatically strips debug symbols.
• For ndk-build, APP_OPTIM := release does the same.
• You can also manually strip symbols using the NDK’s llvm-strip tool:

$NDK/toolchains/llvm/prebuilt/<your-host-platform>/bin/llvm-strip path/to/your/lib.so

4. Remove Unused Code and Dependencies #

Take a hard look at your C/C++ codebase and third-party libraries:

• Delete any unused functions, classes, or modules. If you’re using a large library but only need a small part of its functionality, consider compiling only the required modules instead of the entire library.
• Avoid static-linking unnecessary system libraries whenever possible—dynamic linking (the NDK default for most libraries) keeps your APK size smaller by relying on system-provided libraries.

5. Optimize Library Compression #

Android Gradle Plugin 7.0+ supports more efficient compression algorithms for .so files than the default deflate. Using zstd or lz4 can reduce library size without slowing down app startup significantly.

Enable this in your build.gradle:

android {
    buildTypes {
        release {
            packagingOptions {
                jniLibs {
                    useCompression = 'zstd' // Or 'lz4'
                }
            }
        }
    }
}

6. Use APK Analyzer to Pinpoint Bloat #

Don’t guess where the bulk is coming from—use Android Studio’s APK Analyzer to visualize your APK’s contents. It will show you exactly how much space each .so file, resource, or code component takes up. This helps you identify unexpected bloat (like accidentally included unused libraries) and prioritize your optimization efforts.

内容的提问来源于stack exchange，提问作者Jatin Mandanka