[MUSIC PLAYING] BEN WEISS: One pillar of
modern Android development is distribution. The Android App Bundle is a new
and official publishing format for Android applications. With the Android App Bundle,
we created a publishing format that unlocks,
amongst other things, shipping smaller
apps to your users. Smaller apps are more
likely to be installed, and less likely
to be uninstalled when disk space gets tight. Today, we'll take a closer
look at the technical aspects of how Android App
Bundles can help to decrease your app's size. Getting started doesn't
require any changes to your existing codebase. All you need to do is
create an Android App Bundle using Android Studio
or the command line and then uploading it to Google
Play Store using the Play Console. Once the bundle is
uploaded, the Play Store can optimize the APKs it
delivers to users' devices based on their configuration. This, in turn, reduces
download and installation size. In this video, I
will show you how that's done by taking you
through the process of creating an app bundle, uploading
it to the Play Console, and then showing you tools
that you can use to examine the exact APKs that the Play
Store generates from that app bundle. Let's dive right in. To generate a signed app
bundle using Android Studio, select Build, then
Generate Signed Bundle/APK. On this dialog, make sure
Android App Bundle is selected, then click Next. Here, you have to provide
information on the upload key that you configured
for Play App signing. If you're wondering
what an upload key is or how to enable Play
App signing in general, please check out the previous
video in this series, where this is explained in detail. Let me enter the Key store
password and Key password, then click Next. We're using the build
variant "release," which can be shipped to
users through the Play Store by default. After
clicking Finish, the bundle is generated. When the app bundle is ready,
you can open the Event Log, and then click on Locate to open
the path to the generated app bundle. Choosing Analyze instead
opens the APK Analyzer, which enables you to inspect
the app bundle's content. Before we go ahead and upload
the app bundle using the Play Console, I'm going to show you
how the compilation and signing process works using
the command line. We're essentially going to call
the same commands that Android Studio invokes for you. This can be useful when you
work with a remote machine, are writing a script for a
continuous integration server, or simply have a preference
for using the command line. Android projects ship
with the Gradle wrapper. This wrapper invokes the
declared version of Gradle and downloads it, if necessary. Depending on your
operating system, it's either gradlew
or gradlew.bat. To bundle the application, I'm
invoking the Gradle wrapper and then the bundle command. Since I want to build only
the release variant and not all possible variants,
I'm appending "Release," and then I kick off
the build process. The app bundle now can
be found in the build folder of the common
Android application module. In our case, that is app. From there, we navigate to
/build/outputs/bundle/release. And here, we see the Android
App Bundle that we just built. This is a release bundle
that now needs to be signed. You can do this yourself
in your Gradle script or by invoking the
commands yourself. To sign this app bundle,
we're using jarsigner. We supply the keystore
location using the corresponding parameter
and the keystore location. And then I tell jarsigner
what it should sign-- in this case, app-release.aab. Since a keystore can hold
multiple signing keys, jarsigner wants to know
which key it should use. In order to tell it, I
add the keystore alias as the final parameter
to this command. After hitting Enter, I can
add my super secret passphrase and then hit Enter once again. No matter whether
you choose to use Android Studio or the command
line to build and sign the app, this bundle now can be uploaded
using the Play Console, and that is what we'll do next. In your Applications
Detail screen, click on the preferred
track you want to create your new release on. I'll roll this out
to internal testers before opening it
up to everyone. On the left-hand side, I
select Testing and then Internal testing. Here, I click on
Create new release. To get this going, I'll
upload the app bundle that I've just built and signed. I can either click the Upload
button here, or drag and drop the bundle in the
dedicated area. Once the bundle is
uploaded and processed, we can take a look at
the App Bundle Explorer. In the App Bundle
Explorer, we can see an overview of some
features of the app bundle, such as supported devices,
languages, and permissions. To explore the bundle, I click
on the details arrow here, and then Explore bundle. At this stage, we
can take a look at how the Play Store decides
what should be downloaded to the user's device. In the Downloads tab, we
can see this in detail. Here, I can apply
a lot of filters. They correspond to
the optimizations that Play Store applies
when generating a set of APK for installation on device. The app I uploaded is the
Play Core KTX sample app, which is available on GitHub. You can find the link
to the repository in the video's description. The sample app contains
some rendered icons for different screen densities. So when I set the screen
density to a specific value and download the APK
set for a device, that will provide us with
an APK that mainly contains the rendered images for
that density bucket, alongside some metadata. Let's go ahead and select
devices with 440 to 450 Dots Per Inch, or DPI. Clicking on the Download
icon at the end of the screen gives me the possibility to
make some further selections and download the APKs
for the chosen device. I'll download the default set. Now let's see what Play
had in store for us. The downloaded zip file
contains several APKs, which are tailored to the
specific device in question. Let's take a look. This is the zip file
I just downloaded. Let's go on and unzip it. Here you see all the
APKs that were downloaded for the selected
device, including all potential languages that are
supported by the application. These are the exact APKs that
would be delivered to a user's device with the
chosen configuration, including the signature
from Play App Signing. I did not configure languages
in the Download dialog, which is why there are so
many different language APKs right here. Many users would only install
a subset of these languages, depending on their
configuration. To install them all
locally, you can run adb install multiple
and select all APKs. While each APK in the set
is relevant to guarantee correct execution
of your app, I want to point out that
the base APK always has to be installed on
a user's device in order to provide your app's
core functionality. Next to code and
resources, the base module also contains the
merged Android manifest and shared dependencies
for the entire application. There could be
exceptions, such as when your app has its own
language selector built-in and you want to have
all potential languages available for
selection at all times. But even then, using
the Android App Bundle provides you with ways to
load features on demand. This could be used to
avoid pre-installing parts of your app that only a
subset of users might need. And since we want to enable
users to download and install features in a
programmatic way, we provide an unbundle
API that you can use. It's part of the Play
Core Library, which is covered in the next
video of the "Modern Android Development" series,
where we take a closer look at Play Feature Delivery. To get notified when new
videos get published, subscribe to the Android
Developers channel. If you have questions
on this video's content, please leave a comment. Thank you very
much for watching. Bye. [MUSIC PLAYING]
