What are the differences between gradle assemble and gradle build tasks?

Question

If I am not wrong gradle assemble does run gradle assembleDebug and gradle assembleRelease, but I believe gradle build al

Answer 1

Assemble will build your artifacts, and build will assemble your artifacts with additional checks.

What additional checks? I run the tasks so you don't have to:

:app:lint SKIPPED       
:app:bundleDebugClasses SKIPPED     
:app:kaptGenerateStubsDebugUnitTestKotlin SKIPPED       
:app:kaptDebugUnitTestKotlin SKIPPED        
:app:compileDebugUnitTestKotlin SKIPPED     
:app:preDebugUnitTestBuild SKIPPED      
:app:javaPreCompileDebugUnitTest SKIPPED        
:app:compileDebugUnitTestJavaWithJavac SKIPPED      
:app:processDebugUnitTestJavaRes SKIPPED        
:app:testDebugUnitTest SKIPPED      
:app:bundleReleaseClasses SKIPPED       
:app:kaptGenerateStubsReleaseUnitTestKotlin SKIPPED     
:app:kaptReleaseUnitTestKotlin SKIPPED      
:app:compileReleaseUnitTestKotlin SKIPPED       
:app:preReleaseUnitTestBuild SKIPPED        
:app:javaPreCompileReleaseUnitTest SKIPPED      
:app:compileReleaseUnitTestJavaWithJavac SKIPPED        
:app:processReleaseUnitTestJavaRes SKIPPED      
:app:testReleaseUnitTest SKIPPED        
:app:test SKIPPED       
:app:check SKIPPED      
:app:build SKIPPED

As you can see, build does execute more tasks than assemble. Like lint, test, and check tasks.

You can refer the full tasks here The original text is build task while the changed text is assemble task.

Project used: Android Sunflower GitHub

Answer 2

Assemble will build your artifacts, and build will assemble your artifacts with additional checks.

build depends on assemble, so build is sort of a superset of assemble

You can have a look on the tasks that will be executed by using the --dry-run flag. e.g.

gradlew build --dry-run

You will see that apart from assemble also lint and test will be executed.

Answer 3

There is conflicting information about whether build is supposed to depend on assemble.

On one hand, Understanding Gradle: the Build Lifecycle shows a graph of task dependencies from where build and assemble are independent:

In contrast, the Gradle user guide for Java plugin shows that build depends on assemble, at least for Java projects:

This contradicts the graph from "Understanding Gradle." So perhaps the Android plugin implements build/assemble tasks differently from the Java plugin? Or, this behavior changed in some version of Gradle.

Answer 4

From gradle tasks --all:

Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.

build is effectively assemble + check (and check is test + any linting tasks).

Answer 5

It's true that according to gradle tasks it looks like the build is a superset of assemble, including tests. But(!) from my short experience it really looks like it's not the case.

So I ran those 2 commands in the command line using the gradle wrapper with --scan flag after running clean every time. This is the comparison:

1. Desired built files:
   • After running assembleDebug I got all the built files i wanted - *.apk and *.aar files.
   • After running buildDebug I didn't have any of those files.
2. Amount of tasks ran according to the scans:
   • assembleDebug - 109 tasks
   • buildDebug - 91 tasks
3. Amount of dependencies according to the scan:
   • assembleDebug - 172 from 20 configurations
   • buildDebug - 104 from 18 configurations
   • It seems like the reason they differ is that in assembleDebug in 2 of my 3 sub projects (which are java libraries, not app) there is one more configuration, called lintClassPath. This configuration is missing in buildDebug.
4. Another point to mention is that when I searched in the tasks list, it seemed like buildDebug didn't call assembleDebug task and assembleDebug didn't call buildDebug tasks.
5. And the last interesting thing to mention in this context is that when I ran build from the Android Studio (Build -> Make Project), I see in my scan that the command that actually ran was the assembleDebug. More specifically, it ran :app:assembleDebug.

As you can see, I don't really understand the differences myself, but this is what I found out. If someone can explain it to me and the other users reading here, it could be awesome :) Thanks!