Dynamic feature module, Android OnDemand module : Android App Bundle : Part-3
Recap of previous post
In my previous post, I had discussed the intro of dynamic feature module. I explained what’s the concept, when to use and what’s the advantages of it.
In my previous article, I discussed base and configs apks as a part of Dynamic Delivery concept. In this article, I’ll discuss the Dynamic Feature Apks which is also one of the parts of the Dynamic Delivery concept. If your app has the dynamic feature module then google play automatic generates the dynamic feature apks and serves to the users when it’s required. Read in this article in the section: Dynamic feature modules
PitStops
Modularized Android App Bundle Format
If you’re familiar with the Android App bundle format then it’s easy to understand the format of the modularized bundle (app bundle with the dynamic feature module bundle). There will be the separate directory for each dynamic feature module along with base directory. The format of these additional directories is exactly the same as the format of base which I covered in the earlier part. Let’s take a look at the example of the modularized bundle. In the following image, there are two dynamic feature modules available inside the app bundle one is add_recipe and another is vr_viewer. You can see they both have the same format as base app module.
Consider an app with three dynamic feature modules and support for multiple device configurations. The below figure illustrates how it looks like: There is a base module with base configuration apks (language +densities+ abis), morevoer, there are three dynamic feature modules which have their own base/master apks plus configuration apks for each module. You can see the dynamic feature 2 has all kind of configs apks, the same thing applies to the other two dynamic feature modules.
So far, you’ve understood the format of modularized app bundle and how apk splits works for dynamic module feature.
Creating a Dynamic Feature Module:
Let’s see how to add dynamic feature module in the application.
- Prerequisite is: Android Studio (3.2.0 Canary 14+)
- Select File > New > New Module from the menu bar and Create New Module dialog, select Dynamic Feature Module and click Next. Specify all the required details as per your need.
- Give the module title as you wish ( up to 50 characters), this title will be visible to the users when your app asks to download dynamic feature module to the user. Thus, it should be localized. You will see that there are two other configuration options:
enable onDemandandFusingcheckbox too, I’ll explain about those later in this article when we’ll discuss the AndroidManifest file of the dynamic-feature module.
Dynamic Feature Module’s AndroidManifest file
Let’s understand the newly created dynamic feature module’s AndroidManifest file. For more details check here.
- The first thing is to declare your module as a new split apk of your application, you need to provide the split tag in the manifest’s root tag:
split=”custom_dynamic_feature” - The next part is
<dist:module/>tag, you can provide your feature module’s title and other configurations. This tag will be used by Google Play Store to identify the modules in your application, - You can define the
dist:onDemand="true/false"attribute which gives the indication that this module is only available to the user when the user requests from the application and it won’t be available during the first installation. - As you know On demand modules and configuration splits are only available on Lollipop+ devices, if you want to make them available on pre L devices then instruct play store to install this module alongside with base module or universal apk at time of the first/initial app install.
Dynamic feature module’s build.gradle
Let’s understand the newly created dynamic feature module’s build.gradle .
- The first thing is, now, Android using the new plugin called
'com.android.dynamic-feature'to build the dynamic feature module. - In dependencies block, we need to specify the base/main application’s module name. So, we can access the functionality of the base/main application’s module.
Change in main/base module build.gradle
You must declare your all dynamic feature modules in the base/main application’s build.gradle file. This is to instruct to the gradle that you need all your resources and code available to the other dynamic modules. The below code is from base/main app’s build.gradle. Here I’ve declared the all dynamic feature modules.
What not to include in the dynamic feature module build configuration
Following configuration needs to mention in the main/base module’s build.gradle file.
- Signing configurations
- Code shrink/minifyEnabled property : You can specify additional ProGuard rules for each dynamic feature module using the
consumerProguardFilesproperty in module build.gradle file.
- Versioning (
versioncode and versionname)
How to Install dynamic feature modules
Let’s take a look at code and understand how to install/manage on demand modules with help of Play-Core library. It’s java client lib which communicates with Play Store via IPC.
- Dependency :
implementation ‘com.google.android.play:core:1.2.0’ - Create request and start installing the module. You can skip downloading the module if t’s already installed.
private var manager = SplitInstallManagerFactory.create(this)/**
* Load a feature by module name.
* @param name The name of the feature module to load.
*/
private fun loadAndLaunchModule(name: String) {
updateProgressMessage("Loading module $name")
// Skip loading if the module already is installed. Perform success action directly.
if (manager.installedModules.contains(name)) {
updateProgressMessage("Already installed")
onSuccessfulLoad(name, launch = true)
return
}
// Create request to install a feature module by name.
val request = SplitInstallRequest.newBuilder()
.addModule(name)
.build()
// Load and install the requested feature module.// Submits the request to install the module through the
// asynchronous startInstall() task. Your app needs to be
// in the foreground to submit the request.
.startInstall(request)
// You should also be able to gracefully handle
// request state changes and errors. To learn more, go to
// the section about how to Monitor the request state.
manager.startInstall(request)
}
- The API also allows you to listen for the updates through out the download/install process. You can this progress data to show display the progress of download/install to your users while they’re waiting for on-demand (dynamic feature module) to download.
- For the large modules you need to obtain the user confirmation prior to start download/install the dynamic feature module. You need to write the code for it.
- For the all error code and status handling check the official android developers website. I’ll try to explain the practical/code in the upcoming post.
Deploy your app
While you’re developing your app with support for Dynamic Delivery, you can deploy your app to a connected device like you normally would by selecting Run > Run from the menu bar (or by clicking Run in the toolbar). It installs the universal apk to your device. However, If your app project includes one or more dynamic feature modules, you can choose which dynamic features to include when deploying your app by modifying your existing run/debug configuration as follows:
- Select Run > Edit Configurations from the menu bar.
- From the left panel of the Run/Debug Configurations dialog, select your desired Android App configuration.
- Under Dynamic features to deploy in the General tab, check the box next to each dynamic feature module you want to include when deploying your app.
- Click OK.
In the below screenshot, only dynamic_feature and kotlinmodules are going deployed with the base application, assets and javamodules aren’t going to deploy.
Side Note: kotlin, java,assets these are just dynamic feature module names, there is no relation with language/lib
Note: You can’t test dynamic feature modules locally, If you want to test downloading and installing dynamic feature modules on demand, you must do so after uploading your app bundle and using the Play Console internal test track.
That’s it !! I’ll try to post one more article of it with coding.
