In the world of mobile development, efficiency and scalability are key to delivering high-quality apps. One of the most effective ways to achieve both is by adopting modular architecture in your Android apps. Android’s Dynamic Feature Modules (DFMs) take modularity to the next level, enabling you to not only break down your app into smaller, manageable components but also to deliver those components on demand. This means you can reduce your APK size, improve build times, and provide a smoother user experience with faster app downloads and updates.

In this blog, we’ll explore how to implement modular architecture using Dynamic Feature Modules, how they impact build times, and how they empower your app to become more efficient.

What are Dynamic Feature Modules?

Dynamic Feature Modules allow you to separate certain features of your Android app and deliver them dynamically after the initial installation. Users can download these features only when they are needed, rather than bundling everything into a single APK. This approach is particularly useful for large applications that may have many features, some of which are rarely used.

For example, a travel app might have an augmented reality (AR) feature for exploring nearby locations. Instead of bundling this feature with the app’s core functionality, it can be delivered on-demand when the user explicitly accesses the AR feature.

Benefits of Dynamic Feature Modules

1. Smaller APK Sizes

By splitting your app into multiple modules, you can significantly reduce the size of the base APK that users initially download. Users only need to download the core functionality of the app upfront, and additional features are loaded as needed. This improves the user experience, especially in regions with slower internet connections.

2. Faster App Updates

Because your app is modular, updates are also modular. Instead of pushing updates to the entire app, you can update specific modules independently. Users only need to download changes for the affected features, making updates faster and more efficient.

3. Improved Build Times

Building a large monolithic app can result in longer build times, slowing down development cycles and reducing productivity. Dynamic Feature Modules allow developers to break up the app into smaller modules, leading to improved build performance. Developers can work on individual modules independently without having to recompile the entire project, which speeds up incremental builds and reduces the overhead on continuous integration (CI) systems.

4. On-Demand Features

Dynamic features are delivered only when the user interacts with certain parts of the app. This is especially useful for less frequently used features, as users don’t have to install components they won’t immediately need. For example, a photo-editing app could download advanced filters only when the user selects them, keeping the core app lightweight.

Example Use Case: Travel App with On-Demand Features

Imagine a travel app that provides users with different tools, but not all are needed right away. Here’s how Dynamic Feature Modules could work:

1. Core App Features: Users can search for flights and hotels. These are core functions downloaded with the base app.
2. On-Demand Feature: Currency Converter
   The app has a currency converter feature that users can access only when needed. It’s part of a dynamic feature module. When a user taps the “Currency Converter” button, the app will download the feature on demand using the SplitInstallManager.
3. On-Demand Feature: AR City Guide
   Another feature allows users to explore cities in Augmented Reality (AR). This feature will only be downloaded when a user is in a city and clicks the “AR Guide” button. The app triggers the download, and once the feature is ready, the AR experience starts.

This way, users don’t need to download everything upfront, saving both time and space.

An Everyday Example:

Imagine you’re buying a new car. When you buy it, you get all the basic features: the engine, wheels, and seats. But what if you don’t need all the extra fancy features like a sunroof, heated seats, or a premium sound system right away? You could buy the car with just the basics, and when you’re ready, the dealership can add the extra features for you, one by one, as you need them.

Similarly, with Dynamic Feature Modules, when you download an app, you only get the essential parts. If the app has special features (like a photo editor or a fancy game mode), you can download those later when you’re ready to use them.

How Does It Help Build Time for Developers?

Imagine you’re building a house. Instead of building the entire house all at once, it’s easier and quicker to work on one room at a time. You might finish the living room first, then move on to the kitchen, and so on. This is much faster than trying to complete every single part of the house at the same time.

Similarly, when developers build apps, the more features and parts the app has, the longer it takes to put everything together. But with Dynamic Feature Modules, developers can work on and test individual parts of the app separately. This means:

1. Faster Development: If a developer is fixing a problem in the “wishlist” part of a shopping app, they don’t need to rebuild the entire app – just that one part. This speeds up the process.
2. Better Testing: Testing a smaller part of the app is easier and quicker than testing everything at once. If developers can test just the new feature, it means fewer mistakes and faster improvements.
3. Parallel Work: With modular apps, multiple developers can work on different features at the same time. For example, one person can work on the photo editor while another developer is working on the sharing feature. This makes development more efficient.

Implementing Modular Architecture with Dynamic Feature Modules

Step 1: Setting Up the Base Module

The base module is the main part of the app that users download first. It includes the essential features. To let the app know that some features will be downloaded later as Dynamic Feature Modules, you need to declare them in your base module‘s build.gradle file.

Here’s an example:

In this code:

• dynamicFeatures is used to list all the dynamic modules (like “:dynamicfeature”) that can be downloaded later. These modules will be delivered on demand.

Step 2: Creating a Dynamic Feature Module

Next, you need to create a separate feature module that will be downloaded only when the user needs it. Here’s how you can create it in Android Studio:

1. Go to File > New > New Module.
2. Select Dynamic Feature Module.
3. Name the module (for example, “dynamicfeature”).

Once created, make sure to set the base module as the dependency in the dynamic feature module’s build.gradle:

Step 3: Defining How the Feature Is Delivered

Dynamic Feature Modules can be delivered in different ways. You can make them available on-demand (only downloaded when needed) or at install time (downloaded alongside the base app).

To configure this, you need to define how the module should be delivered in the AndroidManifest.xml file:

In this code:

• dist:installTime=”false” ensures that the feature won’t be installed with the base app.
• dist:onDemand means this feature will be downloaded when the user accesses the feature.
• dist:fusing lets you include the module in the main APK for devices that don’t support on-demand delivery.

Step 4: Requesting a Dynamic Feature Module

When the user wants to access a feature that isn’t part of the initial download, the app needs to download the module. To do this, Android provides the SplitInstallManager API. Here’s how you can trigger the download of a feature module when the user requests it:

In this code:

• SplitInstallManager handles the process of requesting and installing a feature module.
• addModule(“dynamicfeature”) specifies which feature module to download.
• Once the download completes, you can take action, like starting a new activity that uses the downloaded feature.

Step 5: Using the Dynamic Feature

Once the feature is downloaded, you can use it just like any other part of the app. You can open a new activity or use any functionality inside the module.

For example, to start an activity from the dynamic feature module:

Here’s a guide on how to handle modular navigation with NavGraph and Fragments using Dynamic Feature Modules:

Step 1: Setting Up Your Base Module with Navigation

In the base module (the main app that’s always downloaded), you set up the NavGraph and declare the dynamic feature modules in the navigation component. Here’s how to configure the base module:

1. Add Navigation Component dependencies in the build.gradle file of your base module:
2. Create the Navigation Graph (res/navigation/nav_graph.xml) in your base module. Define the fragments from both the base module and dynamic feature modules. For fragments that belong to dynamic feature modules, use the <include-dynamic> tag.

Here’s an example:

Here:

• include-dynamic points to the NavGraph of the dynamic feature module (when it’s downloaded).

Step 2: Create the Dynamic Feature Module

Next, create the dynamic feature module that will contain the fragment you want to load on demand.

1. Create a new Dynamic Feature Module in Android Studio (as outlined earlier).
2. In the dynamic feature module, create a navigation graph for the feature.

Here’s an example of the navigation graph (dynamic_feature_nav_graph.xml) inside the dynamic feature module:

In this file:

• The dynamicFeatureFragment is the fragment contained within the dynamic feature module. It will be loaded dynamically when the user navigates to it.

Step 3: Loading the Dynamic Feature Module with Navigation

When a user navigates to a fragment that belongs to a dynamic feature module, you need to trigger the download of that module. You can do this using SplitInstallManager just like before.

Here’s an example of how you can navigate to a fragment from the dynamic feature module after downloading it:

1. First, in your base module, use the NavController to navigate to the fragment. But before navigation, you check if the module is already installed; if not, you download it.

How It Works:

1. Check if the module is installed: The getInstalledModules() method checks whether the dynamic module is already installed.
2. Download the module if not installed: If it’s not installed, the SplitInstallManager requests the download.
3. Navigate to the dynamic fragment: Once the module is installed, the NavController navigates to the fragment inside the dynamic module.

Step 4: Navigation from the Dynamic Feature Module

Once the dynamic feature module is installed and the user is viewing the fragment, they may want to navigate back to a base module fragment or even to another dynamic module.

You can handle this the same way you would with regular navigation, like so:

In this example, action_dynamicFeatureFragment_to_baseFragment is an action in your NavGraph that navigates from the dynamic feature back to a fragment in the base module.

Conclusion

Dynamic Feature Modules offer a powerful way to implement modular architecture in Android apps. They help you manage large codebases more efficiently by enabling on-demand feature downloads, reducing APK size, and significantly improving build times. By incorporating DFMs into your app, you can create a more scalable, maintainable, and performance-optimized project that enhances both development speed and user experience.

Whether you’re working on a complex app with multiple features or a smaller app looking to scale, Dynamic Feature Modules can help you build a faster, leaner Android application.