Develop Reference

Compile gradle task only when executed

We've written some custom gradle tasks in Kotlin, and as they've grown, they've moved from build.gradle to buildSrc. These tasks are for processes that run in CI and developers don't really need them on their local machines.
The issue is that any time we modify these scripts, when developers pull latest their next gradle command takes an extra 15+ seconds because it has to compile buildSrc again.
Is there a best practice for how I can get ./gradlew <my-custom-task> to automatically compile and run a Kotlin task from somewhere in the project, but if I run ./gradlew build it ignores my task and does not attempt to compile it?

Gradle dependency tree for "test" task different in different projects

I am running "gradlew test" task in my 2 android projects- in one it has a dependecy on mergeDebugAssets task while in other it doesn't have.
Though I want my "gradlew test" task to have dependency on mergeDebugAssets because otherwise I am not able to access assets from folder- build/intermediates/bundles/debug in my test.
I don't think it is appropriate to explicitly modify test task for this.
Also, should it depend on android sdk or buildtools version or gradle version? Though I kept the gradle version of 2 projects same but same is happening. Where am I missing?

Run a gradle task before resolving dependencies

I want to run a gradle task that fetches additional sources and sets them up before gradle tries to resolve dependencies.
In build.gradle there is a task that fetches a sub project's source code. The task needs to be run before Gradle tries to resolve dependencies, because the sub project is part of the dependencies. The task involves fetching sources from a remote repository and replacing a few build.gradle files to make the build possible.
What happens now is that:
I run the task.
Gradle tries to resolve dependencies before actually running the task.
It fails because one of the dependencies requires the sub project (the sources that my task is supposed to fetch).
Of course, resolving dependencies is part of the "Configuration" build phase, so it's pretty clear why the task is run after. The question is how to make it run before.
Of course I can make it work if I replace my gradle task with a separate bash script and run it manually before gradle does anything. However, that would mean that I duplicate some variables in the gradle and the bash scripts (like version names and git tag names). Those variables are used for other purposes in gradle, and having them in two places is bad. There are other reasons I want to avoid that, one of them being - using a bash script would mean that gradle fails at doing our build from start to finish...

Firstly you are incorrect that resolving dependencies is part of the "Configuration" phase. If you make use of the lazy evaluation of FileCollection then it will actually be resolved in the execution phase. A configuration will be resolved the first time that resolve() is invoked. Please see the javadoc for the methods which cause a Configuration to be resolved. AFAIK the core gradle code won't resolve a configuration in the "Configuration" phase but your custom code may cause this (I suggest you refactor if this is the case)
You can do something like this:
dependencies {
// this is lazy evaluated
compile fileTree(dir: "$buildDir/dynamicJars", include: "*.jar")
}
task getDynamicJars(type: Copy) {
from zipTree('path/to/somefile.zip')
into "$buildDir/dynamicJars"
}
compileJava.dependsOn getDynamicJars

Compile Android project from the command line as if it was the first time, everytime?

When compiling my project from the command line I get to see the beauty of caching in action, a lot of tasks are skipped -- which is really good -- but in my case Im trying to test and find out whats slowing down my build; so how can I compile the project from the command line as if it was the first time, everytime?

If you want gradle to ignore up-to-date status of tasks, run with
--rerun-tasks
If you also want to re-download all dependencies, add
--refresh-dependencies
Quick side note: when gradle skips tasks because it's outputs are already up to date, it isn't exactly caching, but gradle's incremental builds feature in action.

Gradle - Which task creates the 'build' directory?

I'm using Android Studio 1.3.2 on Mac.
Gradle version is listed as 2.2.1, Android Plugin version 1.3.1.
I have applied the FindBugs Gradle plugin, and I've created a task that successfully runs the analysis on the directory 'build/intermediates/classes'.
To trigger this task on Gradle Sync, I've added it as a dependency to the preBuild task, like this:
preBuild.dependsOn findBugs
The problem with this dependency is that, at time of preBuild, the generated class files are either non-existent (first sync) or stale (remaining from previous sync). Basically, I want my task to run immediately after the 'build/intermediates/classes' directory is created, or when the files there are refreshed as part of the 'Sync' operation.
Looking at the tasks available, I can see the 'clean' task has the following description:
clean - Deletes the build directory.
However, none of the other tasks I see describe the directory's creation. My first thought was "Well, it's got to be the build task, right?". Unfortunately, as usual, it's not that simple (pressing gradle 'sync' button, does not trigger my task when I've added it as a dependency to the 'build' task). Is no such task available? If so, which task would best suit what I'm trying to achieve?

You can see all tasks using ./gradlew tasks
The build task is the main one. It builds everything, generates APKs and runs all checks.
I recommend you adding the following to the build.gradle file:
check.dependsOn 'findbugs'
So when you run the check task, it will execute findbugs as well.
Then also set a dependency on findBugs for the compilation task:
task findbugs(type: FindBugs, dependsOn: 'compileDebugSources') {...}
This will compile the source in case you run findbugs without previously compiling it.