使用api而非implementation是否会增大Android APK体积？场景答疑

Hey there! Let's unpack your questions about api vs implementation—these are crucial details for optimizing both build times and APK size, so great to ask!

Question 1: Will using api instead of implementation increase APK size in Android development? #

Short answer: No, not directly. Here's why:

• Android's default build tools (R8/ProGuard) handle code shrinking, which strips out any unused code from your final APK—regardless of whether the dependency was added with api or implementation.
• The core difference between api and implementation is about dependency visibility, not whether code gets included in the APK. api exposes the dependency to all modules that depend on your current module, while implementation keeps it internal to the module.
• If you use api for a dependency but never actually use any of its code (directly or indirectly) in your app, that dependency's code will still be removed during the shrinking process. Code only ends up in your APK if it's actively used in your app's code path.

Question 2: If Module B uses api to add lots of unnecessary dependencies, and Project A depends on Module B—will this increase APK size (we already know it hurts build times)? #

The answer hinges on whether those "unnecessary" dependencies are actually being used somewhere in your codebase:

• If none of the dependencies' code is used in Project A or Module B: R8/ProGuard will strip all that unused code from the final APK, so your APK size won't grow. The build time slowdown comes from api making those dependencies visible to Project A—any change to those dependencies will trigger a rebuild of Project A, even if it never uses them.
• If some of the dependencies' code is used (even indirectly): For example, if Module B uses a class from one of those api dependencies, and Project A uses that part of Module B, then that class will be included in the APK. But this isn't a flaw with api specifically—if Module B had used implementation for that dependency, the code would still be included (since Module B uses it), and Project A would still get it via Module B's compiled output.
• Edge case: If a dependency has code that can't be shrunk (like code accessed via reflection, or marked with @Keep annotations) and Module B includes it via api even though no one uses it, that code might end up in the APK. But this is rare, and it's more of an issue with the dependency itself than with using api.

To sum up: Overusing api primarily impacts build times (due to broader dependency visibility triggering more rebuilds), not necessarily APK sizes—unless those extra dependencies bring along code that's actually used in your app.

内容的提问来源于stack exchange，提问作者Artur A