DEV Community

Daniele Bottillo
Daniele Bottillo

Posted on

How I made my legacy app modular - part 2

This is part two of

In part 1, I've shown how to move from one big module to three:

Three modules architecture

The idea behind these three modules is that we can start to move our codebase in three directions:

  • everything that is shared across modules should be moved to core (eg. util extensions, app constants)
  • everything that is app level configuration should be moved to app (eg. dagger configuration, navigation)
  • everything that is related to one feature should have its own module as a sibling of legacy: Sibling modules architecture

The reason behind this approach is that we can move code away from legacy which will force us to think about the dependencies of feature: being a sibling of legacy means that we can't access anything inside legacy so we have to move those dependencies either to core or app.

A good example of this approach of creating siblings of legacy is the extraction of a small feature on my own project: the about page of the app.
App about page

It's a small screen with few buttons, a title, some texts and a box with the libraries used inside the app; it makes the perfect example of how to extract it considering that it has very few dependencies on legacy.

Let's first create the gradle module for the about module feature:


That's it! The last folder will contain all the logic for the module. To make the module "alive" we need to add its definition to the settings.gradle:

include ':legacy', ':core', ':app'
include ':feature_about'  <- add this

So now syncing the project will make the feature_about module available in Android Studio. Let's start moving the AboutActivity which is inside the legacy module:


Move also all the drawables that are used from AboutActivity from legacy to feature_about.

eg: move 

Right, so AboutActivity is now out of legacy, exciting! But this is also where the problem starts: what if you have a drawable that is shared with the rest of the application? or a dimension?

There are two options to handle those cases:

  • move the shared resources into core
  • duplicate the resources from legacy

I don't think there is a generic solution that works here, it really depends on the specific use case. I would advice to move dimensions like base_margin to core, whilst I would prefer to duplicate things like specific drawables so that the module has full control over that.

Right, next step is to update the manifest because the AboutActivity is not visible anymore in legacy: we can move it from the legacy manifest to the about module one:

File: app/src/main/AndroidManifest.xml

   <activity android:name=".ui.about.AboutActivity"/> <- remove
File: feature_about/src/main/AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
        <activity android:name=".AboutActivity"/>

The extraction is completed! Almost…because probably inside the legacy module somewhere we must have something like:


but AboutActivity is no longer visible in legacy module. Here is where the app module comes into play, we need to wire the navigation between modules now. The difficulty comes from the fact that the only module that has visibility to all the features is app but we need to find a way to call one module from its sibling. My personal solution around navigation is to define an interface in core called Navigator:

file: core/src/main/kotlin/com/dbottillo/mtgsearchfree/Navigator.kt

interface Navigator {
    fun openAboutScreen(origin: Activity)

which is visible from all the modules and have the implementation in app:

file: app/src/main/kotlin/com/dbottillo/mtgsearchfree/Navigator.kt

class AppNavigator : Navigator {
override fun openAboutScreen(origin: Activity) {

And in each module we can inject Navigator whose implementation doesn't really matter at feature module level: the important part is that they have a class to request to move between screens, the actual implementation is at runtime from the app module.

We are almost there! I just mentioned "inject Navigator", so how do we achieve that? how does Dagger work? It's actually quite simple!

Let's first create a Dagger module in the about module:

file: feature_about/src/main/kotlin/com/dbottillo/mtgsearchfree/dagger/AboutModule.kt

abstract class AboutModule {
    @ContributesAndroidInjector(modules = [(BasicAboutModule::class)])
    abstract fun contributeAboutActivityInjector(): AboutActivity
class BasicAboutModule

We also need to create an AppModule Dagger module to provide the navigator dependency:


class AppModule {
    fun provideNavigator(): Navigator {
        return AppNavigator()

And now we can add both modules to the app component:

@Component(modules = [
interface AppComponent : AndroidInjector<DaggerApplication> {

And that's it! Now Dagger knows how to provide dependencies inside the about module. Of course this is a very simple example as it doesn't have any API request or database, so the module is very simple but is a good starting point :)

If you want to see the real commit behind this story:

As for part 1, in the real code legacy module is actually called MTGSearch and the complexity of that commit is slightly higher than the one described here.

Happy modularisation!

Top comments (0)