KOGE

Gradle Lifecycle ​

Understanding the Gradle Lifecycle ​

gradle-lifecycle

The lifecycle of Gradle itself can be understood from the diagram above. Key points include:

  • The main process, marked by multiple black modules, represents the core execution phases within the Gradle framework's lifecycle.
  • The white modules on the left, connected by dashed lines, are lifecycle hooks attached to the Gradle object. For instance, you can use gradle.afterProject {} to pass a closure that is triggered after each Project is initialized.
  • The white modules on the right, also connected by dashed lines, are lifecycle hooks attached to the Project object. For example, you can trigger a hook by passing a closure to project.afterEvaluate {}.

Official documentation on the three major lifecycle phases is somewhat rudimentary. It is recommended to read the second article below for a more comprehensive understanding:

  1. "Build Lifecycle"@Gradle
  2. "Gradle 103: Build Life Cycle"@Shivam

Regarding lifecycle hooks, only about 30% are commonly used. The links below include API documentation for these interfaces and practical examples of using afterEvaluate and tasks.whenReady{}:

  1. "Interface BuildListener"@Gradle
  2. "Interface TaskExecutionListener"@Gradle
  3. "Interface Project"@Gradle
  4. Search afterEvaluate{} on "Triple-T/gradle-play-publisher"@AlexSaveau
  5. "How to exclude a task in Gradle?"@Brook'sStudio
  6. Caution with Using afterEvaluate{}

Android Gradle Plugin (AGP) Lifecycle ​

While there is no official "lifecycle" reference for AGP, its process can be broadly divided into:

  1. Safety checks.
  2. Configuration and creation of various Builders, Extensions, Services, etc.
  3. Creation of Tasks, whether Variant-related or not.

This process is similar to implementing a simple custom Plugin, but with a vastly larger scale of logic, including a variety of internal tools and services. For beginners, it's more important to understand what tasks are performed during the execution phase, their order, and how to interact with them. For more information, refer to:

  1. Regular Tasks
  2. Customized Tasks

Summary ​

This section is crucial for understanding some of Gradle's design principles. Here are some efficient tips:

  • Avoid any IO or CPU-intensive operations during the Configuration phase. Utilize various lazy APIs to register Tasks and parse files for parameters.
  • Refrain from registering numerous lifecycle callbacks in the root project using subprojects{ ... }, as it can impact performance. Instead, use plugins to refine granularity and enable on-demand loading. Often, not every sub-project requires the same logic.