Overview of Play Feature Delivery

Google Play’s app serving model uses Android App Bundles to generate and serve optimized APKs for each user’s device configuration, so users download only the code and resources they need to run your app.

Play Feature Delivery uses advanced capabilities of app bundles, allowing certain features of your app to be delivered conditionally or downloaded on demand.

Use feature modules for custom delivery

A unique benefit of feature modules is the ability to customize how and when different features of your app are downloaded onto devices running Android 5.0 (API level 21) or higher. For example, to reduce the initial download size of your app, you can configure certain features to be either downloaded as needed on demand or only by devices that support certain capabilities, such as the ability to take pictures or support augmented reality features.

Although you get highly optimized downloads by default when you upload your app as an app bundle, the more advanced and customizable feature delivery options require additional configuration and modularization of your app’s features using feature modules. That is, feature modules provide the building blocks for creating modular features that you can configure to each be downloaded as needed.

Consider an app that allows your users to buy and sell goods in an online marketplace. You can reasonably modularize each of the following functionalities of the app into separate feature modules:

• Account login and creation
• Browsing the marketplace
• Placing an item for sale
• Processing payments

The table below describes the different delivery options that feature modules support, and how they might be used to optimize the initial download size of the sample marketplace app.

Modularize your app

Modularizing your app is the process of separating logical components of your app project into discrete modules.

Reorganizing your app’s functionality into these discrete components takes careful consideration and time. However, modularization provides your project with the following benefits:

• Develop in parallel: By separating logical components of your app into modules, different teams or individuals in your organization can take ownership of each module and work on them with fewer merge conflicts or disruptions to other teams. Additionally, if you have logic that’s used in various parts of your app, you can use library modules to promote code reuse and encapsulation.
• Improve build times: Build systems, such as the Android Studio build system using Gradle, are optimized for projects that are organized into modules. For example, if you enable Gradle’s parallel project execution optimization on a workstation includes a multi-core processor, the build system is able to build multiple modules in parallel and significantly reduce build times. The more modular your project is, the more significant the build performance improvement becomes.
• Customize feature delivery: Modularizing your app’s features as feature modules is a requirement to take advantage of Play Feature Delivery’s custom delivery options, such as on demand, conditional, and instant delivery. Creating on demand features requires more effort and possible refactoring of your app. So, consider carefully which of your app’s features would benefit the most from being modularized into feature modules and benefiting from custom delivery options.

Modularizing your project by app features takes time and consideration to do properly. When you do decide to begin modularizing your app, you should first configure your base module with the properties necessary to support modular features. Then, you can gradually modularize your app’s features without changing the current behavior of your app by configuring feature modules for install-time delivery.

Feature module manifest

When creating a new feature module using Android Studio, the IDE includes most of the manifest attributes that the module requires to behave like a feature module. Additionally, some attributes are injected by the build system at compile time, so you needn’t specify or modify them yourself. The following table describes the manifest attributes that are important to feature modules.

Test Play Feature Delivery

The best way to test Play Feature Delivery is through the Google Play Store. That's because a lot of the benefits of Play Feature Delivery rely on deferring optimized APK generation, signing, and serving to the Play Store. So, whether you simply upload an app bundle or configure more advanced delivery options, you should use the following methods to test your app.

• Share your app with a URL. This is the fastest way to upload your app bundle and share your app as a Google Play Store link with trusted testers. Additionally, this is the fastest way to test custom delivery options, such as downloading features on demand.
• Set up an open, closed, or internal test. This method provides structured test channels and is a good way to test the final release version of your app before you roll it out to external users.

Building a URI for a resource

If you want to access a resource stored in a feature module using a URI, here’s how to generate a feature module resource URI using Uri.Builder():

val uri = Uri.Builder()
                .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
                .authority(context.getPackageName()) // Look up the resources in the application with its splits loaded
                .appendPath(resources.getResourceTypeName(resId))
                .appendPath(String.format("%s:%s",
                  resources.getResourcePackageName(resId), // Look up the dynamic resource in the split namespace.
                  resources.getResourceEntryName(resId)
                  ))
                .build()

String uri = Uri.Builder()
                .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
                .authority(context.getPackageName()) // Look up the resources in the application with its splits loaded
                .appendPath(resources.getResourceTypeName(resId))
                .appendPath(String.format("%s:%s",
                  resources.getResourcePackageName(resId), // Look up the dynamic resource in the split namespace.
                  resources.getResourceEntryName(resId)
                  ))
                .build().toString();

Each part of the path to the resource is constructed at run time, ensuring that the correct namespace is generated after the split APKs have been loaded.

As an example of how the URI is generated, suppose you have an app and feature modules with these names:

• App package name: com.example.my_app_package
• Feature's resources package name: com.example.my_app_package.my_dynamic_feature

If the resId in the code snippet above refers to a raw file resource named “my_video” in your feature module, then the Uri.Builder() code above would output the following:

android.resource://com.example.my_app_package/raw/com.example.my_app_package.my_dynamic_feature:my_video

This URI can then be used by your app to access the feature module’s resource.

To validate the paths in your URI, you can use the APK Analyzer to inspect your feature module APK and determine the package name:

Figure 2. Use the APK Analyzer to inspect the package name in a compiled resource file.

Considerations for feature modules

With feature modules, you can improve build speed and engineering velocity and extensively customize delivery of your app's features to reduce your app's size. However, there are some constraints and edge cases to keep in mind when using feature modules:

• Installing 50 or more feature modules on a single device, via conditional or on-demand delivery, might lead to performance issues. Install-time modules, which are not configured as removable, are automatically included in the base module and only count as one feature module on each device.
• Limit the number of modules you configure as removable for install-time delivery to 10 or fewer. Otherwise, the download and install time of your app might increase.
• Only devices running Android 5.0 (API level 21) and higher support downloading and installing features on demand. To make your feature available to earlier versions of Android, enable Fusing when you create a feature module.
• Enable SplitCompat, so that your app has access to downloaded feature modules that are delivered on demand.
• Feature modules should not specify activities in their manifest with android:exported set to true. That's because there's no guarantee that the device has downloaded the feature module when another app tries to launch the activity. Additionally, your app should confirm that a feature is downloaded before trying to access its code and resources. To learn more, read Manage installed modules.
• Because Play Feature Delivery requires you to publish your app using an app bundle, make sure that you're aware of app bundle known issues.

Additional resources

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

Samples

• PlayCore API sample, which demonstrates usage of the PlayCore API to request and download feature modules.
• Dynamic code loading sample, which demonstrates three different approaches to safely access code from an installed feature module.

Codelabs

• Your First Android App Bundle, a codelab that explores the basic principles of Android App Bundles and shows you how to quickly get started with building your own using Android Studio. This codelab also explores how to test your app bundles using bundletool.
• On demand modules, which helps you create an app that downloads and installs feature modules on demand.

Blog posts

• What a new publishing format means for the future of Android
• New features to help you develop, release, and grow your business on Google Play
• The latest Android App Bundle updates including the additional languages API
• What a new publishing format means for the future of Android
• Patchwork Plaid — A modularization story
• Google Santa Tracker — Moving to an Android App Bundle

Videos

• Customizable Delivery with the App Bundle and Easy Sharing of Test Builds
• New Tools to Optimize Your App's Size and Boost Installs on Google Play
• Bundling an App in an Instant