Posted by Wojtek Kaliciński, Developer Advocate, Android
Last year, we launched Android App Bundles and Google Play's Dynamic Delivery to introduce modular development, reduce app size and streamline the release process. Since then, we've seen developers quickly adopt this new app model in over 60,000 production apps. We've been excited to see developers experience significant app size savings and reductions in the time needed to manage each release, and have documented these benefits in case studies with Duolingo and redBus.
Thank you to everyone who took the time to give us feedback on our initial launch. We're always open to new ideas, and today, we're happy to announce some new improvements based on your suggestions:
When you adopt the Android App Bundle as the publishing format for your app, Google Play is able to optimize the installation by delivering only the language resources that match the device's system locales. If a user changes the system locale after the app is installed, Play automatically downloads the required resources.
Some developers choose to decouple the app's display language from the system locale by adding an in-app language switcher. With the latest release of the Play Core library (version 1.4.0), we're introducing a new additional languages API that makes it possible to build in-app language pickers while retaining the full benefits of smaller installs provided by using app bundles.
With the additional languages API, apps can now request the Play Store to install resources for a new language configuration on demand and immediately start using it.
The app can get a list of languages that are already installed using the SplitInstallManager#getInstalledLanguages() method.
SplitInstallManager#getInstalledLanguages()
val splitInstallManager = SplitInstallManagerFactory.create(context) val langs: Set<String> = splitInstallManager.installedLanguages
Requesting an additional language is similar to requesting an on demand module. You can do this by specifying a language in the request through SplitInstallRequest.Builder#addLanguage(java.util.Locale).
SplitInstallRequest.Builder#addLanguage(java.util.Locale)
val installRequestBuilder = SplitInstallRequest.newBuilder() installRequestBuilder.addLanguage(Locale.forLanguageTag("pl")) splitInstallManager.startInstall(installRequestBuilder.build())
The app can also monitor install success with callbacks and monitor the download state with a listener, just like when requesting an on demand module.
Remember to handle the SplitInstallSessionStatus.REQUIRES_USER_CONFIRMATION state. Please note that there was an API change in a recent Play Core release, which means you should use the new SplitInstallManager#startConfirmationDialogForResult() together with Activity#onActivityResult(). The previous method of using SplitInstallSessionState#resolutionIntent() with startIntentSender() has been deprecated.
SplitInstallSessionStatus.REQUIRES_USER_CONFIRMATION
SplitInstallManager#startConfirmationDialogForResult()
Activity#onActivityResult()
SplitInstallSessionState#resolutionIntent()
startIntentSender()
Check out the updated Play Core Library documentation for more information on how to access the newly installed language resources in your activity.
We've also updated our dynamic features sample on GitHub with the additional languages API, including how to store the user's language preference and apply it to your activities at startup.
Please note that while the additional languages API is now available to all developers, on demand modules are in a closed beta for the time being. You can experiment with on demand modules in your internal, open, and closed test tracks, while we work with our partners to make sure this feature is ready for production apps.
In Android Studio 3.3, we introduced a way to build app bundles that contain both the regular, installed version of your app as well as a Google Play Instant experience for modules marked with the dist:instant="true" attribute in their AndroidManifest.xml:
dist:instant="true"
AndroidManifest.xml
<manifest ... xmlns:dist="http://schemas.android.com/apk/distribution"> <dist:module dist:instant="true" /> ... </manifest>
Even though you could use a single project to generate the installed and instant versions of your app, up until now, developers were still required to use product flavors in order to build two separate app bundles and upload both to Play.
We're happy to announce that we have now removed this restriction. It's now possible to upload a single, unified app bundle artifact, containing modules enabled for the instant experience. This functionality is now available for everyone.
After you build an instant-enabled app bundle, upload it to any track on the Play Console, and you'll be able to select it when creating a new instant app release. This also means that the installed and instant versions of your app no longer need different version codes, which will simplify the release workflow.
You need to enable app signing by Google Play to publish your app using an Android App Bundle and automatically benefit from Dynamic Delivery optimizations. It is also a more secure way to manage your signing key, which we recommend to everyone, even if you want to keep publishing regular APKs for now.
Based on your feedback, we've revamped the sign-up flow for new apps to make it easier to initialize the key you want to use for signing your app.
Now developers can explicitly choose to upload their existing key without needing to upload a self-signed artifact first. You can also choose to start with a key generated by Google Play, so that the key used to locally sign your app bundle can become your upload key.
Read more about the new flow.
We have now added the ability to permanently uninstall dynamic feature modules that are included in your app's initial install.
This is a behavior change, which means you can now call the existing SplitInstallManager#deferredUninstall() API on modules that set onDemand="false". The module will be permanently uninstalled, even when the app is updated.
SplitInstallManager#deferredUninstall()
onDemand="false"
This opens up new possibilities for developers to further reduce the installed app size. For example, you can now uninstall a heavy sign-up module or any other onboarding content once the user completes it. If the user navigates to a section of your app that has been uninstalled, you can reinstall it using the standard on demand modules install API.
We hope you enjoy these improvements and test them out in your apps. Continue to share your feedback as we work to make these features even more useful for you!
How useful did you find this blog post?
★ ★ ★ ★ ★
