[MUSIC PLAYING] ALAN VIVERETTE: Hi,
I'm Alan Viverette. And I'm a Technical Lead on the
Android Jetpack Team at Google. In this talk, I'll be covering
the latest Jetpack libraries as well as some
important changes to prerelease library features. For the uninitiated,
Android Jetpack is a suite of libraries,
tools, and guidance to help developers
follow best practices, reduce boilerplate
code, and write code that works consistently
across Android versions and devices. In short, Jetpack
makes it easier for developers to focus on
the code they care about. And since last year,
adoption of Jetpack has continued to skyrocket. In 2020, we reported
that just under half of the top 1,000 apps were
using two or more Jetpack libraries, not including
core libraries like AppCompat or Lifecycle. Today, over 3/4, 79%,
of the top 1,000 apps rely on Jetpack,
and for good reason. We've continued to improve
our existing libraries. And we've also
introduced new libraries to cover common pain points
and make development easier. Before we get to
libraries, though, I want to acknowledge
a bit of feedback that we've gotten
from the community. Jetpack releases
a lot of alphas. So we've made some
small changes. Alphas are the same. These are libraries
under active development. Features may be
incomplete, but what's there is tested and should
be highly functional. Once the library is
feature complete, it moves to beta
for stabilization. And here's the change-- there may be rare instances
where APIs change in response to critical feedback. We understand that alpha has
certain implications outside of the strict definitions
that we use for versioning. So what this means
in practice is that libraries whose features
are stable but may need more developer feedback
will reach beta sooner with the same level of
functional stability the developers
expect from a beta. While it's nice to have
more flexibility in beta, there occasionally features
that just need more time. Jetpack has introduced
new metadata and tooling to isolate individual
features, meaning developers will see libraries reach
stable much sooner. In practice, feature
isolation looks like this. APIs are annotated as part of
an experimental feature set. And then any calls to it
require explicit opt-in. For folks using
Kotlin, this might seem familiar-- the
"requires opt-in" annotation. Jetpack has introduced
an equivalent set of Java
annotations as well as a lint check that enforces
the same opt-in semantics as the Kotlin compiler. So opting in means that
the developer understands that the API is
alpha quality, and it may change in the future. And when the feature
is stabilized, the annotation can be removed. We use this
extensively in Jetpack. But the annotation-bundled
lint check are available for anyone to
use in their apps or libraries. One of the places where
you may see experimental is CameraX, where
it's being used to ensure that the library
can move to stable as devices continue to evolve. The CameraX library provides
a unified API surface for access and
camera functionality across OS versions, including
device-specific compatibility fixes and workarounds. Some of the latest
improvements to the library address common feature
requests, including support for adjusting exposure
compensation and access to more detailed information
about camera state and features. Additionally, camera
settings like FPS range may now be changed
via camera2 inter-op while the camera is running. The library also brings support
for the latest device and OS features, including high
dynamic range preview, zoom ratio controls, and
support for Android's do-not-disturb mode. Perhaps most importantly,
though, the library has continued to
address performance, resulting in faster
image capture and faster initialization, especially
on older devices. To support more robust
application design, the most recent alpha version
of the CameraX library has split CameraView
into CameraController, which provides interaction
with camera features like zoom and focus and
preview view, which is responsible for
rendering the camera preview and integrating with
the Android view system. Here, we're setting a
preview and taking a photo. But CameraController
provides much more, including image analysis and
additional capture options. For developers interested
in full-text search, the new AppSearch library
provides high performance and feature-rich
search functionality. AppSearch provides
everything you'd expect from full-text search. And in comparison to SQL,
the AppSearch library makes it easy to
perform fuzzy matching, handle synonyms and
spelling correction, support multiple
languages, and much more. AppSearch simplifies
data representation by including schemas
for common object types based on schemas.org
and on Android S and later. It allows developers
to surface their data in device-wide search. For developers that just
want to store basic data, the DataStore library
provides a robust approach that addresses the shortcomings
of SharedPreferences while maintaining a simple,
highly usable API service. As a modern replacement
for SharedPreferences, DataStore brings support
for best practices like Kotlin coroutines
with Flow and RxJava. DataStore also provides multiple
ways to define a data model-- as a loosely typed
key-value store that's similar to the
old SharedPreferences model, a proto DataStore,
which stores strongly typed objects using
protocol buffers, or whatever fits the use case. So why should
developers migrate? Well, while SharedPreferences
works OK for smaller apps, DataStore can provide strong
guarantees around type safety, asynchronous operations,
and error handling, as well as a number of useful
features like data migration. Migrating from
SharedPreferences to a basic key-value preferences
DataStore is simple. Here, we're creating a
SharedPreferences migration object and passing in the
name of our SharedPreferences and then using it to
create our DataStore. That's it. Now we can access
our preferences using the new DataStore model. And for developers who
are storing preferences, wouldn't it be nice to
provide safety guarantees for your security-critical
preferences? The Security Crypto
library does just that, providing an easy way to
encrypt files and preferences. The library has
recently launched a stable with
DataStore integration planned for a future version. To encrypt
SharedPreferences, simply create an encrypted
SharedPreference object with the appropriate
key and scheme. And then use it like you would
a standard SharedPreferences object. Also moving to 1.0
stable, we have Hilt, Jetpack's recommended
dependency injection solution built on top of Dagger. As part of the
transition to stable, Hilt's ViewModel support has
moved up into the core Hilt Android APIs. And SavedStateHandle has been
added as a default dependency available in the component. A developer can obtain an
annotated Hilt ViewModel from an Android entry point,
like an activity or a fragment, or obtain a ViewModel scoped
to the entry point's navigation back stack. Hilt has also made improvements
to WorkManager integration, using AssistedInject. With this change,
developers no longer need to create their
own worker factory and pass in
dependencies manually. They can now obtain
the dependencies from Hilt's dependency
injection graph and remove quite a bit
of boilerplate code. Additionally, Hilt
has made improvements to testing with the new
TestInstallIn annotation. This annotation allows you
to uninstall and replace modules in tests with
build performance improvements over the existing
UninstallModules annotation. Here, all tests
that would normally be injected with
RepositoryModule will instead receive the
FakeRepository module. The WorkManager library, which
is Android's recommended way to schedule deferrable,
asynchronous tasks that run even if the app exits
or the device restarts, has made improvements
to reliability, with task reconciliation
ensuring all tasks are executed and a variety of workarounds for
specific Android OS versions. The latest versions
of WorkManager feature improved support
for multi-process apps, including performance benefits
from unifying work request scheduling into a single process
and limiting database growth when scheduling many requests. Version 2.7, which is
targeted to the Android S SDK, provides additional support for
the platform's new foreground restrictions. See the effect of background
tasks on Android Talk for more information on using
WorkManager on Android S. We're also very pleased to
announce that the WorkManager Inspector is now available
in Android Studio Arctic Fox. This tool allows developers
to easily view and debug WorkManager jobs when using the
latest versions of the library. The Inspector tool can be opened
from Android Studio's Tool Windows menu. And from there,
the tool displays the active workers in
an app live on device. Developers can perform
operations on workers, including removing them
from the queue or stopping execution, which can
help investigate issues with scheduled jobs. The tool can also provide
more detailed information about an individual worker,
including how it's executed, details of its worker chain,
and execution results. Room, Jetpack's recommended
data persistence layer, which provides
increased usability and safety over the platform,
has also reached stable. The latest version
of the library brings experimental support
for Kotlin Symbol Processing, which, in our benchmarks
of Kotlin code, showed a 200% speed
improvement over kapt, as well as built-in support
for enums and RxJava3. Room has also introduced
a QueryCallback class, which provides a callback when
SQLite statements are executed to simplify tasks like logging. As well as the new
ProvidedTypeConverter annotation, which
allows more flexibility when creating type converters. Previously,
developers had to rely on static methods,
no-arg constructors, and build time verification. With this annotation, however,
the type conversion object can be constructed at
runtime with whatever additional information
it needs, and Room will verify its availability
when the database is built. On the user interface
side of Jetpack, ConstraintLayout, a flexible
system for designing layouts, has reached 2.0 stable. Along with it, MotionLayout
is now stable and ready to provide rich animation
and state management. MotionLayout is based
on ConstraintLayout and provides no-code-necessary
motion animation, including support for foldable
devices, image filters, and motion effects. And Studio's Motion
Editor gives developers an interactive visual tool
for designing animations. Check out the "What's
New in Design Tools" talk to learn more
about using Motion Editor with MotionLayout. Over the past year,
the Fragment library has undergone a major
effort to clean up its internal implementation and
reduce undocumented behavior, making it easier for
developers to follow best practices in their apps
and write reliable tests. This lays the groundwork
for future improvements to the library. And it may require some work to
accommodate strict enforcement of API contracts. In practice, this
means that developers should pay careful
attention to their tests after updating the library. The Fragment release notes
call out specific cases to watch out for. Recent releases have also added
ActivityResult integration, making it possible to
register for ActivityResults from a fragment. Fragment has also introduced
a new FragmentOnAttachListener interface to replace the less
flexible onAttachFragment. Existing code that overrides
the method in FragmentActivity will still work. But we've deprecated
onAttachFragment to help prevent new code from
accidentally adopting a less flexible approach. The latest alpha
of Fragment also integrates with the Navigation
library, Jetpack's framework for moving between
destinations in an app to provide support for
multiple back stacks and simplify cases
where destinations sit at the same depth, such
as a bottom navigation bar. For developers who'd like
to integrate more closely with Google Assistant, the
Google Shortcuts library provides a way to expose actions
to Assistant and other Google services through the
existing ShortcutInfo class. Developers can send
up to 15 shortcuts at a time through
the ShortcutManager to be shown on Google
Assistant, among other services, making them available for
voice and other interactions. Here, we've defined a shortcut
with an intent and capability binding. This binding provides
semantically meaningful information that will help
Google services figure out the best way to
surface it to users. And for any app that might
need to display emoji, which, at this point, is basically
any app with a text input or network-backed
data, the EmojiCompat library has introduced a
new major version with a smaller footprint. Any app that's using
AppCompat 1.4 or later will automatically
pull in EmojiCompat, giving it the ability to
dynamically load new emoji and stay current with
the latest Unicode spec. Apps that aren't using AppCompat
can receive the same benefits by pulling in the
EmojiCompat TextView class and using it in place of
the platform TextView. Paging, which helps developers
load portions of data to improve performance
and resource consumption, also joins the
stable release club with its 3.0 major version. This release features a
complete rewrite in Kotlin with first-class support
for coroutines and Flow, asynchronous loading with
RxJava and Guava primitives, and overall improvements to
the presentation and repository layers. The 3.0 release is a
substantial improvement in usability over Paging
2.0, and the rewrite was planned with partial
and staged migrations in mind so that
developers can transition on their own schedule. For developers interested
in understanding their app's performance, the
Macrobenchmark library extends Jetpack's
benchmarking coverage to app startup and
integrated behaviors like scrolling performance. The library can be used
remotely to track metrics in continuous
integration testing or locally with profile results
viewable from Android Studio. Check out the "Measuring
Jank and Startup with Macrobenchmark"
talk to learn more about using the library. We're also pleased
to announce that many of the libraries I've
talked about today, as well as others developers
are already using, have introduced
features specifically for integration with Jetpack's
new UI toolkit, Compose. Make sure to check out
the "Jetpack Compose" talk to learn more about
the new UI tool kit and watch the "Using Jetpack
Libraries and Compose" talk to learn how
to use the latest versions of popular
Jetpack libraries, including Navigation,
ConstraintLayout, and more with Compose. Jetpack is also making it
easier to write UI for new form factors, including foldables,
large-screen devices, and Wear devices. Check out the "What's
New in Foldables" and "Now is the Time" talks
to learn more about developing for these form factors. We've covered a lot of
libraries in this talk, but there are quite
a few more new and updated libraries
that developers might want to check out. Full details for
every Jetpack library, including release notes,
Maven coordinates, and API reference
docs can be found on
developers.android.com/jetpack. Tip-of-tree library snapshots
are available at androidx.dev. Thanks for watching,
and have a nice day. [MUSIC PLAYING]
