If I am not wrong <code>gradle assemble</code> does run <code>gradle assembleDebug</code> and <code>gradle assembleRelease</code>, but I believe <code>gradle build</code> also does the same, so what are the different between them both?

<code>assemble</code> will build your artifacts, and <code>build</code> will assemble your artifacts with additional checks. <code>build</code> depends on <code>assemble</code>, so <code>build</code> is sort of a superset of <code>assemble</code> You can have a look on the tasks that will be executed by using the <code>--dry-run</code> flag. e.g. <pre class="prettyprint"><code>gradlew build --dry-run </code></pre> You will see that apart from <code>assemble</code> also <code>lint</code> and <code>test</code> will be executed.

From <code>gradle tasks --all</code>: <pre class="prettyprint"><code>Build tasks ----------- assemble - Assembles the outputs of this project. build - Assembles and tests this project. </code></pre> <code>build</code> is effectively <code>assemble</code> + <code>check</code> (and <code>check</code> is <code>test</code> + any linting tasks).

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

There is conflicting information about whether <code>build</code> is supposed to depend on <code>assemble</code>. On one hand, Understanding Gradle: the Build Lifecycle shows a graph of task dependencies from where <code>build</code> and <code>assemble</code> are independent: <img src="https://i.stack.imgur.com/uD56m.png" alt="Directed acyclic graph for the Java plug-in tasks from the book Gradle Recipes for Android."> In contrast, the Gradle user guide for Java plugin shows that <code>build</code> depends on <code>assemble</code>, at least for Java projects: <img src="https://i.stack.imgur.com/2EC7g.png" alt="Java plugin - tasks"> 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.

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

If I am not wrong gradle assemble does run gradle assembleDebug and gradle assembleRelease, but I believe gradle build also does the same, so what are the different between them both?

What is Gradle build task?

Gradle Tasks In Gradle, Task is a single unit of work that a build performs. These tasks can be compiling classes, creating a JAR, Generating Javadoc, and publishing some archives to a repository and more. It can be considered as a single atomic piece of work for a build process.

What does Gradlew assemble do?

Assemble is for creating artifacts (eg WAR or JAR) from the various components, classpaths, resource files, etc.

What is assemble task?

Assemble is a lifecycle task with no actions attached. Lifecycle tasks often combine other tasks and are useful to run in your development workflow. The purpose of assemble is to combine all tasks which produce a distribution or artifact into a single task.

Does Gradle assemble run tests?

By default, Gradle will run all tests that it detects, which it does by inspecting the compiled test classes. This detection uses different criteria depending on the test framework used. For JUnit, Gradle scans for both JUnit 3 and 4 test classes.

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.

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).

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:

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.
Amount of tasks ran according to the scans:
- assembleDebug - 109 tasks
- buildDebug - 91 tasks
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.
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.
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!

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: Directed acyclic graph for the Java plug-in tasks from the book Gradle Recipes for Android.

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

Java plugin - tasks

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.

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

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

Tags:

android

android-gradle-plugin

Humble Student

People also ask

5 Answers

David Medenjak

Laurence Gonsalves

Doron Go

Colin D Bennett

aldok

Recent Activity

Donate For Us

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

Tags:

android

android-gradle-plugin

Humble Student

People also ask

5 Answers

David Medenjak

Laurence Gonsalves

Doron Go

Colin D Bennett

aldok

Related questions

Recent Activity

Donate For Us