Compile, Provided, APK - Android dependency scope

问题:

While adding new dependencies to android project especially in Android Studio in Dependencies there are three scope options Compile/Provided/APK.

What are the effects of choosing each one, when should we use them ? Besides what the name says.

EDIT:

"Properly handle 'provided' and 'package' scopes to do what they should be doing. 'provided' and 'package' cannot be used with Android Libraries, and will generate an error" .. this is from http://tools.android.com/tech-docs/new-build-system

回答1:

• provided - compile-time only dependency
• package - package-time only dependency
• compile - compile-time and package-time dependency

provided is commonly used for annotation processing based libraries. Usually these libraries are separated in two artifacts - "annotation" and "compiler". "compiler" is provided dependency because you do not need to use it in application, only for compilation; and "annotation" is compile dependency - it is used in application code and therefore compiles. Or generated code may require additional dependencies while your application may not. E.g. dagger dependencies configuration:

compile 'com.squareup.dagger:dagger:1.2.2'
provided 'com.squareup.dagger:dagger-compiler:1.2.2'

回答2:

These properties come from maven scopes.

They simply indicate how to treat particular dependencies during each step of build process.

1. compile - a default approach, it simply means that all dependencies should be available at compile-time. Compile dependencies are available in all classpaths of a project. Furthermore, those dependencies are propagated to dependent projects. A compile-time dependency is generally required at runtime.

2. package - declares additional configuration for building an application. You can list plugins that add additional functionality to the build process.

3. provided - it means that runtime environment has these dependencies included. For example, when you look into android.jar library internals you will see java.lang.RuntimeException: Stub! in every method body.

   That has some consequences:
   • You can develop Android applications locally, without having complete Android environment.
   • Your APK you must run it on an android device or an emulator because they provide implementation of these methods.
   • Your apps that reference the SDK classes will build properly, because the jar provides the class metadata.
   • Unless you use some library that provides artifacts (e.g. Robolectric), you have to run tests on your emulator/device.

provided and package cannot be used with Android Libraries, and will generate an error.

Here is how sourceSet looks like:

More info about build system: https://www.youtube.com/watch?v=LCJAgPkpmR0

An awesome article about Gradle: http://www.sinking.in/blog/provided-scope-in-gradle/

回答3:

Xavier talks here about the APK scope.

in the Android plugin, The equivalent (sort of) of runtime is called apk. You can do

dependencies { apk files('libs/foo.jar') }

and it'll only get packaged but won't be on the compile classpath.