Register now for Android Dev Summit 2019!

Configure at-install delivery

Dynamic feature modules allow you to separate certain features and resources from the base module of your app and include them in your app bundle. Through Dynamic Delivery, you can then customize delivery options to control when and how devices running Android 5.0 (API level 21) or higher download your app's features.

Keep in mind, this type of modularization requires more effort and possibly refactoring your app’s existing code, so consider carefully which of your app’s features would benefit the most from being available to users on demand.

If you want to gradually modularize app features over time, without changing the behavior of your app or customizing advanced delivery options, you can do so by creating dynamic feature modules that are configured for at-install delivery. That is, you can modularize a feature as a dynamic feature, but not enable advanced options so the feature is available when a user installs your app.

Additionally, it might be useful to create dynamic features that you configure for at-install delivery because you have the option to later uninstall that feature if it's no longer required. For example, to reduce the installed size of your app, you can modularize content that's required for training or onboarding, and then uninstall the dynamic feature module after the user is set up to use your app.

This section describes how to create a dynamic feature module for at-install delivery. Before you begin, make sure you're using Android Studio 3.3 or higher and Android Gradle Plugin 3.3.0 or higher.

Configure a new module for at-install delivery

The easiest way to create a new dynamic feature module is by using Android Studio 3.3 or higher. Because dynamic feature modules have an inherent dependency on the base app module, you can add them only to existing app projects.

To add a dynamic feature module to your app project using Android Studio, proceed as follows:

  1. If you haven’t already done so, open your app project in the IDE.
  2. Select File > New > New Module from the menu bar.
  3. In the Create New Module dialog, select Dynamic Feature Module and click Next.
  4. In the Configure your new module section, complete the following:
    1. Select the Base application module for your app project from the dropdown menu.
    2. Specify a Module name. The IDE uses this name to identify the module as a Gradle subproject in your Gradle settings file. When you build your app bundle, Gradle uses the last element of the subproject name to inject the <manifest split> attribute in the dynamic feature module’s manifest.
    3. Specify the module’s package name. By default, Android Studio suggests a package name that combines the root package name of the base module and the module name you specified in the previous step.
    4. Select the Minimum API level you want the module to support. This value should match that of the base module.
  5. Click Next.
  6. In the Configure On-Demand Options section, uncheck the box next to Enable on-demand. If you want to learn how to create a dynamic feature that you can download after app install, read configure on-demand delivery.
  7. Click Finish.

After Android Studio finishes creating your module, inspect its contents yourself from the Project pane (select View > Tool Windows > Project from the menu bar). The default code, resources, and organization should be similar to those of the standard app module.

Dynamic feature module build configuration

When you create a new dynamic feature module using Android Studio, the IDE applies the following Gradle plugin to the module’s build.gradle file.

// The following applies the dynamic-feature plugin to your dynamic feature module.
// The plugin includes the Gradle tasks and properties required to configure and build
// an app bundle that includes your dynamic feature module.

apply plugin: 'com.android.dynamic-feature'

Many of the properties available to the standard application plugin are also available to your dynamic feature module. The following sections describe the properties you should and shouldn’t include in your dynamic feature module’s build configuration.

What not to include in the dynamic feature module build configuration

Because each dynamic feature module depends on the base module, it also inherits certain configurations. So, you should omit the following in the dynamic feature module’s build.gradle file:

  • Signing configurations: App bundles are signed using signing configurations that you specify in the base module.
  • The minifyEnabled property: You can enable code shrinking for your entire app project from only the base module’s build configuration. So, you should omit this property from dynamic feature modules. You can, however, specify additional ProGuard rules for each dynamic feature module.
  • versionCode and versionName: When building your app bundle, Gradle uses app version information that the base module provides. You should omit these properties from your dynamic module’s build.gradle file.

Establish a relationship to the base module

When Android Studio creates your dynamic feature module, it makes it visible to the base module by adding the android.dynamicFeatures property to the base module’s build.gradle file, as shown below:

// In the base module’s build.gradle file.
android {
    ...
    // Specifies dynamic feature modules that have a dependency on
    // this base module.
    dynamicFeatures = [":dynamic_feature", ":dynamic_feature2"]
}

Additionally, Android Studio includes the base module as a dependency of the dynamic feature module, as shown below:

// In the dynamic feature module’s build.gradle file:
...
dependencies {
    ...
    // Declares a dependency on the base module, ':app'.
    implementation project(':app')
}

Specify additional ProGuard rules

Although only the base module’s build configuration may enable code shrinking for your app project, you can provide custom ProGuard rules with each dynamic feature module using the proguardFiles property, as shown below.

android.buildTypes {
     release {
         // You must use the following property to specify additional ProGuard
         // rules for dynamic feature modules.
         proguardFiles 'proguard-rules-dynamic-features.pro'
     }
}

Note that these ProGuard rules are merged with those from other modules (including the base module) at build time. So, while each dynamic feature module may specify a new set of rules, those rules apply to all modules in the app project.

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).

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:

  1. Select Run > Edit Configurations from the menu bar.
  2. From the left panel of the Run/Debug Configurations dialog, select your desired Android App configuration.
  3. 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.
  4. Click OK.

By default, Android Studio doesn't deploy your app using app bundles to deploy your app. Instead, the IDE builds and installs APKs to your device that are optimized for deployment speed, rather than APK size. To configure Android Studio to instead build and deploy APKs and instant experiences from an app bundle, modify your run/debug configuration.

Additional resources

To learn more about using supporting Dynamic Delivery, try the following resource.

Blog posts

Videos