Android App Bundles: Getting Started

Creating a Signed App Bundle From Android Studio

Go to Android Studio ▸ Build ▸ Generate Signed Bundle / APK.

Select Android App Bundle and click Next.

Introduce your app signing configuration and click Next.

On the next screen, choose a Destination Folder and Build Type, and then click Finish. Simple. :]

Creating an App Bundle From the Command Line

With the availability of App Bundles, you now have some new Gradle tasks to produce an .aab:

Run the bundle task for CountOnMe, from the project root folder, in this case countonme-starter:

./gradlew app:bundle

You will see that the app.aab file is generated at the following path.

/countonme-starter/app/build/outputs/bundle/debug/app.aab

You can use the following commands to create the app bundle for a specific build variant.

./gradlew modulename:bundleVariant

Here buildVariant could be the buildDebug or buildRelease task.

The location of the output file will be:

/modulename/build/outputs/bundleVariant/app.aab

The same signing process used for traditional APKs is compatible with App Bundles.

Publishing an App Bundle in the Play Store

To publish your App Bundle to the Play Store, the first thing you need do is enroll in App Signing by Google Play. After enrolling, you can manage your releases as you did with APKs.

After uploading your App Bundle, you have the opportunity to review your release.

The Google Play console will generate all the APKs for your user configurations. A nice tool for visualizing all those APKs is Bundle Explorer.

Go to Release Management ▸ Artifact library, then select one of the bundles that you have uploaded and click EXPLORE

Now you can see all the savings that an App Bundle provides, and all the APK files that it generated.

You can go even deeper by clicking VIEW DEVICES, and see the specific devices that an APK is going to be delivered to.

The Bundle Explorer can be a great tool while debugging, when you want to know the exact file that a user received on their device.

App Bundles are also available in the Publishing API for automation.

Testing App Bundles

The Google Play Store provides a convenient way to test your App Bundle called Internal Test Track. This is a special track wherein you can invite a closed list of users to test your app.

The Internal Test Track is similar to the Alpha and Beta tracks. The difference is that you don’t have to wait very long with the Internal Test Track, because it’s available almost instantly after you upload your App Bundle file. That helps to ensure that what your users are going to receive is the same as what your QA team is testing.

In the Play Store console, go to Release Management ▸ App Releases ▸ Internal test track

There you can create a list of up to 100 testers.

You can then share the Opt-in URL link with your testers. This link allows the users on the test list to download your app.

Using Bundletool

Bundletool is a command-line tool that helps you to manipulate Android App Bundles. This is the same tool that the Play Store uses to generate .apk files from a .aab file. Additionally, the source code of Bundletool is available as an open source project on GitHub, in case you want to take a deeper look at its ins and outs.

Bundletool allows you to test locally and simulate the same process that Google Play does to serve your App Bundle to users, in case you don’t want to test through the Play Store.

It’s your turn to play a bit with Bundletool. :]

Go to the Bundletool release page and download the bundletool-all-[LAST-VERSION].jar file into a new directory called testing-app-bundle. Then rename the jar to bundletool.jar, and copy the debug .aab file that you previously generated to this same directory.

After that, you should have a directory similar to this one:

To execute Bundletool from the command line, you need to use java -jar bundletool.jar followed by any command that you want Bundletool to execute.

Try this with build-apks. This command takes an App Bundle (.aab) file and outputs a set of APKs. To indicate the bundle, you use the argument --bundle, and output is identified with the argument --output.

Open Terminal, navigate to the testing-app-bundle directory and run the following:

java -jar bundletool.jar build-apks  --bundle=app.aab --output=app.apks

After executing the command above, you have a file app.apks:

Pro-tip: If you use the flag --connected-device, you can generate APKs just for the devices connected to your development machine.

java -jar bundletool.jar build-apks  --bundle=app.aab --output=app.apks
--ks=keystore.jks
--ks-pass=<your_keystore>
--ks-key-alias=<your_key_alias>
--key-pass=<your_key>

java -jar bundletool.jar build-apks  --bundle=app.aab --output=app.apks
--ks=keystore.jks
--ks-pass=<your_keystore>
--ks-key-alias=<your_key_alias>
--key-pass=<your_key>

To install your app on a device, you use the command install-apks, which takes an APK set as an input with the argument --apks, then extracts it and installs the corresponding APK on a connected device.

java -jar bundletool.jar install-apks --apks=app.apks

Internally, Bundletool will read the configuration of the connected device and will select the APK that matches the configuration in order to install it on the device. This is the same matching process that the Google Play Console does when a user requests an app.

Using Bundletool, you can replicate the same process that Google Play uses. This is a great tool for testing locally.

You’ve seen just a small set of things you can do with Bundletool. You can find more in the complete reference.

A Closer Look at Bundletool Output

You’ll now take a closer look at the APK set file app.apks in the testing-app-bundle folder. Change the extension of app.apks to app.zip and uncompress it using your favorite unzipping tool.

Now you have an app directory. Inside this directory there’s a sub-folder called splits. In there, you can find all the APK variations.

Cool! :]

Now, try a small experiment, taking one of these split APKs and comparing it with a traditional APK.

You’ll take the base-es.apk file and open it with the APK Analyzer tool in Android Studio, by going to Build ▸ Analyze APK.

Navigate to the splits folder in the test-app-bundle directory you made, choose base-es.apk and click OK.

base-es.apk is a small file of just 5.3 KB, and it only contains the string resources for the Spanish language.

Now for the other side of the coin, a traditional (universal) APK file. A universal APK contains all the resources for every possible device configuration your app supports, and it’s the traditional way to distribute an app.

Go to Build ▸ Build Bundle(s) / APK(s) ▸ Build APK(s):

Then choose the APK file in app/build/outputs/apk/debug:

As you can see above, the universal APK has everything in it! It’s a much bigger 2.6 MB vs 5.3 KB file, like comparing an 🐜 versus an 🐘.

APK Analyzer allows you to diff two APKs, by going to the upper right corner and clicking the Compare with previous APK button, then navigating to and choosing the base-es.apk file:

Here’s the diff between the universal APK and base-es.apk:

Now you see the real power of App Bundles in action!