Easy navigation in a multi-module Android project

Photo by Alexander Andrews on Unsplash

N26, my current company, has gone through hypergrowth in the last couple of years. As an example, the Android team has gone from 4 to almost 40 engineers. Such growth brought its share of technical challenges like build times and code ownership amongst others.

In order to tackle them, we decided to adopt a multi-module approach where each Gradle module would contain a single feature that belongs to a unique team.

ACTIVITY NAVIGATION

Traditionally, in Android, the most straightforward way to navigate from one Activity to another is as it follows:

val intent = Intent(this, DemoActivity::class.java)
startActivity(intent)

However, in this approach, what do you do when the origin Activity is in one module (let’s say FeatureA) and the destination Activity is in another module (FeatureB)?

Well, you could make FeatureA depend on FeatureB, right?

Now, what if that destination Activity (which is in FeatureB) needs to navigate to another Activity contained in FeatureA?

The answer is that you can’t! The above will cause a circular dependency between your Gradle modules, furthermore, coupling independent features between each other will bring the technical challenges described above.

USE OF SETCLASSNAME

As we started modularising our project, we immediately faced the issue mentioned above.

Therefore, different options were considered, thus it was decided to go for the one that is, at the moment, kind of “recommended” by Google, and which consists in using the setClassName method from Intent.

val intent = Intent()
intent.setClassName(this, “com.gaelmarhic.demo.DemoActivity”)
startActivity(intent)

As you can see, it is pretty straightforward, and the only thing that you need to do is to hardcode your destination Activity’s full class name.

Using the above approach, you can navigate to any Activity which lives in any module without depending on it.

DID YOU SAY “HARDCODE”?

Apart from the fact that writing hardcoded values in our code is not a great practice, it could also cause a few issues.

For example, if an Activity is renamed or moved and the corresponding hardcoded value is not updated, then the app will compile, but it will crash at runtime while trying to navigate.

In order to avoid this, you could have tests in your CI pipeline that can catch those crashes before you release but you would have to remember to explicitly add a test for each case.

This approach is definitely not safe and not scalable.

MANIFEST TO THE RESCUE

The idea of using a simple method from the Intent API was satisfying, but as discussed above, passing a hardcoded value was not a valid option.

This is when we asked ourselves: “Where can we get all of the Activities’ class names in the project?”, and the answer was: “In the Manifest”.

<activity android:name=”com.gaelmarhic.demo.MainActivity” />
<activity android:name=”com.gaelmarhic.demo.DemoActivity” />

In order to be able to use an Activity, it must be declared in the Manifest. We then knew that we had found our reliable source of truth where we could get our Activities’ class name constants from.

This is how we wrote a Gradle plugin that :

• parses all of the AndroidManifest.xml files in the project
• ensures that the Activities are declared in a fully-qualified manner
• generates a constant per Activity ,which holds its full class name.

const val MAIN_ACTIVITY: String = “com.gaelmarhic.demo.MainActivity”
const val DEMO_ACTIVITY: String = “com.gaelmarhic.demo.DemoActivity”

This way, you can rename or move any Activity, and you know that an up-to-date constant will always be generated.

We have now been using this plugin for 9 months in production.

OPEN-SOURCE

A few weeks ago, I open-sourced a version of the plugin similar to the one that we use at N26.

It is called Quadrant and can be found at https://github.com/gaelmarhic/Quadrant.

To use it in your project, add the following code to your root build.gradle file:

buildscript {
    repositories {
        maven {
            url “https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath “gradle.plugin.com.gaelmarhic:quadrant:$version”
    }
}

Then apply the plugin to the build.gradle file of the module where you want the constants to be generated:

apply plugin: "com.gaelmarhic.quadrant"

Just build your project and the constants will automatically be generated for all of your Activities.

That is all! I hope you enjoyed this post and do not hesitate to get in touch with me if you have any comments.

LINKS

Build a Modular Android App Architecture (Google I/O’19)

GitHub | LinkedIn | Twitter

Thanks to all my Android peers at N26.