Gradle for Android Part 5 (Multi-module build)

Android studio not only allows you to create modules for your app and dependent libraries, but also for Android wear, Android TV, Google App Engine, etc., and these separate modules can be used in a single project. For example, in the later stages of your app development, you may need to use Google Cloud or Android Wear. In this case, you can have three modules in your project: app, google cloud, and Android Wear integration. Understanding multi-module building in one project will speed up your development cycle.

In this chapter, we will learn about multi-module construction and show some practical and useful chestnuts:

• Structure of a multi-module build
• Adding modules to your project
• suggestion

Structure of a multi-module build

Typically, a project contains multiple modules, which are located in a parent folder. In order to tell Gradle the structure of the project and which subfolders contain modules, you need to provide a settings.gradle file. Each module can provide its own separate build.gradle file. We have learned about how settings.gradle and build.gradle work normally, now we just need to learn how to use them.

This is a diagram of the structure of a multi-module project:

 project
 ├─── setting.gradle
 ├─── build.gradle
 ├─── app
  │ └─── build.gradle
 └─── library
       └─── build.gradle

This is the simplest and most direct way to create your multi-module project. The setting.gradle file declares all the modules under the project. It should look like this:

 include ':app' , ':library'  

This ensures that both the app and library modules are included in the build configuration. All you need to do is add subfolders for your modules.

To add the library module as a dependency in your app module, you need to add the following to your app's build.gradle file:

 dependencies {
      compile project( ':library' )
 }

To add a module as a dependency to your app, you use the project() method, which takes the module path as an argument.

If your module also contains submodules, gradle can meet your requirements. For example, you can define your directory structure as follows:

 project
 ├─── setting.gradle
 ├─── build.grade
 ├─── app
 │ └─── build.gradle
 └─── libraries
 ├─── library1
     │ └─── build.gradle
 └─── library2
          └─── build.gradle

The app module is still in the root directory, but now the project has 2 different dependencies. These dependency modules are not located in the root directory of the project, but in a specific dependency folder. According to this structure, you need to define it in settings.xml:

 include ':app' , ':libraries:library1' , ':libraries:library2'  

You'll notice that it's also very easy to declare modules in subdirectories. All paths are centered around the root directory, meaning that when you add a module in a subfolder as a dependency of another module, you should specify the path to the root directory. This means that if the app module in the example above wants to depend on library1, the build.gradle file would need to be declared like this:

 dependencies { 
 
    compile project( ':libraries:library1' ) 
 
 }

If you declare dependencies in subdirectories, all paths should be relative to the root directory. This is because Gradle defines your dependencies based on the root directory of your project.

Build lifecycle

Understanding the build process makes it easier to understand multi-module builds. We talked about the build lifecycle a long time ago. So now you should know the basic process, but there are some important details that may not be clear to you.

In the first step, the initialization phase, gradle looks for the settings.grade file. If the file does not exist, then gradle assumes that you have only a single build module. If you have multiple modules, the settings.gradle file defines the location of these modules. If these subdirectories contain their own build.gradle files, gradle will run them and merge them into the build task. This explains why you need to declare that the dependencies declared in a module are relative to the root directory.

Once you understand how the build task brings all the modules together, the different strategies for building multiple modules become easy to understand. You can configure all modules in a build.gradle file in the root directory. This allows you to easily browse the configuration of the entire project, but it can become a mess, especially if your modules require different plugins. Another approach is to separate the configuration of each module. This strategy ensures that each module does not interfere with each other. This also makes it easier to track changes in your build because you don't have to figure out which change caused a problem in which module, etc.

The best strategy of gradle is hybrid. You can define a build file in the root directory to define the same functions for all modules, and then the build file in each module to configure the parameters that belong only to that module. Android studio follows this principle, which creates a build.gradle file in the root directory, and then creates another build file in each module folder.

Module tasks

When you have multiple modules in your project, you need to think before running tasks. When you run a task from the command line interface, Gradle will find which module to execute the task in. For example, you have a mobile app module and an Android Wear module, and you run the gradlew assembleDebug task. When you change the folder location of one of the modules, Gradle will only run that specific module, even if you use the gradle wrapper in the root directory. For example, when you run ../gradlew assembleDebug in the Android wear module's directory, it will only build the Android wear module.

Switching between different folders to perform different tasks can be frustrating, but fortunately, there are other solutions. You can prepare a special task to execute your module. For example, to build only the Android Wear module, you only need to run gradlew :wear:assembleDebug in the root directory.

Adding modules to your project

It is easy to add a new module in Android studio. This view will also create a build file for you. As shown below:

Add Java dependency library

When you create a new Java module, the build.grade file will look like this:

 apply plugin: 'java'  
 dependencies {
       compile fileTree(dir: 'libs' , include: [ '*.jar' ])
 }

The Java module uses the Java plugin, which means that many Android features are not available here because you don't need them.

The build file also has basic library management, you can add jar files in the libs folder. You can add more dependent libraries according to the content of Chapter 3.

Add the Java module to your app module. That's easy, isn't it?

 dependencies { 
 
  compile project( ':javalib' ) 
 
 }

This tells gradle to include a module called javelin. If you add this dependency to your app module, the javalib module will always be built before your app module.

Add Android dependency library

Similarly, we use the graphical interface of Android studio to create an Android module, and then its build file is as follows:

 apply plugin: 'com.android.library'  

Remember: Android dependency libraries not only contain Java code, but also Android resources, such as manifest, strings, and layout files. After you import the module, you can use all the classes and resource files of the module.

suggestion

I have some advice about multi-module projects, and some things you should know that will save you time.

Running module tasks in Android studio

When you have multiple modules, Android studio will analyze them and display them in the cradle:

The grade GUI makes it easy to run tasks between modules, but it does not run a single task for all modules at once, so if you want to do that, the quickest way is to use the command line.

Speed ​​up your multi-module builds

When you build your multi-module project, gradle will execute all modules in sequence. When your computer has enough memory, it will be faster to make your build process multi-threaded. This feature has been in gradle for a long time, but it is disabled by default.

So if you want to start parallel builds, you need to configure the following properties in the grade.properties file:

 org.gradle.parallel = true  

Gradle will select as many threads as possible to execute your build process, and each thread will execute a module. Parallel executes independent modules, that is, your modules are independent.

Module Coupling

That is, you can reference the properties of other modules in one module, but I don't recommend you to do this. We can define these properties in the build file in the root directory.

Summarize

We learned how to build multiple modules in a project and how adding new modules affects the execution of the build task.

We studied relevant cases and gave some suggestions.

In the next chapter, we will learn about testing and how to use gradle to make your testing easier. We will learn how to run your unit tests in the jvm and how to run the tests on your phone.