[MUSIC PLAYING]
STELLA LOH: Hi.
I'm Stella, and I'm the product lead for Google's initiative
to help developers build multi-device experiences that
work better together.
Today, I'm going to talk about how
you can use the tools that Google is making available so
that you can build your own multi-device experiences.
But first, let's talk about why creating
seamless multi-device experiences that work better
together is important, not only for Google,
but for the ecosystem as a whole.
Google's vision is to build a more helpful Google
for everyone by making the world around us universally
accessible and useful.
What makes this challenging, though,
is that users are buying more and more connected
devices these days.
In the US alone, the average household
owns 25 connected devices now.
These include not only your phones and laptops, but also
your TVs, watches, smart speakers, and even cars.
As users buy more and more connected devices,
there's an expectation that those devices will all
work well together.
However, that isn't always the case.
Just because an app exists on multiple form factors
doesn't always mean that the app is integrated across those form
factors.
Sometimes, the same task doesn't translate well across devices.
And managing all of your devices can be a pain as well.
As a developer, building for a multi-device environment
comes with its own set of challenges.
Devices don't always talk to each other,
as there's a lack of cross-platform integrations
available today.
And users encounter friction because they sometimes
don't remember their login credentials,
or they get frustrated in having to set up
yet another device or app.
And historically, it's been difficult to build, instrument,
and test multi-device experiences
without going out and literally buying a bevy of devices
to test with.
This is an important problem for Google to solve,
but we can't do it without you, our ecosystem of developer
partners.
Our mission is to design, build, and deliver
the core framework and capabilities
that enable devices across the Android device ecosystem
to compound each other's value.
Now, let's get into the details of our multi-device platform.
We've been hard at work on building out a software stack
to enable both platform-driven and developer-driven
multi-device experiences leveraging ultra-wideband,
Bluetooth, and Wi-Fi.
At the bottom of the stack is all our raw connectivity data.
We have existing APIs here for Bluetooth and Wi-Fi today.
Now, the platform recently introduced support
for ultra-wideband, which is a new radio technology that
provides accurate and secure relative positioning,
thus, enabling location and orientation
awareness between phones and other devices.
Essentially, it's like Bluetooth, but way better.
We will have a set of simple ultra-wideband APIs launching
via Jetpack in the coming month.
In the middle is our Nearby layer.
The primary functions of our Nearby layer
are to do Bluetooth advertising and scanning
and to establish connections between devices.
Certain platform features like Nearby Share and Phone Hub
rely on our Nearby capabilities today.
Now, we do have our existing nearby connections API,
but a big limitation to that API is that it only
works on Android devices.
At the top of the stack is our new Business Logic layer.
Here, we will have high-level abstracted APIs
that are ideal for building cross-device experiences.
These APIs will abstract away the underlying connectivity
technologies so you don't have to worry
about what capabilities the user's device has.
These APIs will also support bidirectional communication
between devices so that two devices can not only
talk to each other, but also share a common task.
These APIs will also be backwards compatible
down to API 26, so you can start using them right now.
We also intend to support cross-platform development,
extending beyond Android to cover Chrome OS, iOS, Windows,
and other platforms.
And now I'm going to hand over to Ryan
who will go into more detail on our cross-device APIs.
RYAN AUSANKA-CRUES: Thanks, Stella.
I'm very excited to tell you all about the APIs we're building.
As Stella mentioned, with our cross-device APIs,
we are focused on making it easier
to build truly excellent multi-device experiences.
To do that, we are empathizing with everything
that makes it tough to build, launch, and land
multi-device experiences and allow you to focus
on what makes your application unique
rather than on the underlying infrastructure required.
In particular, we are bringing our APIs
wherever your users are, regardless of operating system
or device type.
Additionally, we want our APIs to be
composable with other technologies rather
than an all-or-nothing monolith, and unlock your creativity
rather than define your experience.
When we mention multi-device experiences,
we think about two main categories.
A personal experience is one where a user interacts
with other devices they own.
An example of this is reading a long article on your phone
and transferring to your tablet without losing where you are.
In a communal experience, a user interacts
with others around them who join on their own devices,
for instance, collecting items for a group food order.
Rather than pass your device around to friends and family,
invite them to contribute to your group order
from their own phones.
When talking to developers about these types of experiences,
the recurrent themes we heard were
challenges with discovering what devices are around them,
reducing friction in authorizing those devices to participate
in an experience, and establishing
secure, private, reliable, and performant connections
between devices.
In addition to addressing those issues,
we are also providing another abstraction
that simplifies moving an experience between devices
and managing those that span multiple devices.
To simplify the work to discover devices that can participate
in a multi-device experience, we extracted
the logic Nearby Share uses to discover and authorize devices
and augmented it with additional capabilities
so that your application can easily join devices
in a shared experience while preserving user privacy.
Initiating the discovery and authorization flows
is as simple as registering a callback that
will be called when devices are authorized for your application
and calling our getDevices method when you want
to trigger our Discover UX.
With authorized devices, you can use our Wake-up API
to trigger a notification on receiver devices
to engage the user to participate in your experience.
On the sender device, you create a WakeUpRequest
that will initiate an intent into your app on a receiving
device where you handle the intent.
Once your application is running on receiving devices,
you can use our secure connection API
to establish bidirectional connections between sending
and receiving devices.
Created connections are data pipes
between devices that are not opinionated
about the format of the data you are transferring.
In this example, we're encoding transmitted texts
as UTF-8 byte arrays.
But you're free to define your own transport protocol.
Connections are one-to-one relationships between a sending
device and a receiving device.
You can also name your connections
should you need more than one.
On the receiving side, we provide a simple way
to register to accept a connection and handle new data
and send responses back to the sender.
Layered above the Discovery, Wake-up, and Secure Connection
APIs I just described, we also provide
an additional abstraction to make it easier
to manage an experience across devices.
One convenience our Sessions API provides
is a way to move an experience from the sending
device to a receiver device.
This is designed for building great, seamless handoff
experiences.
Creating a session will implicitly
trigger the device discovery flow I described earlier.
Session creation also requires you to provide a session state
callback implementation that handles
state changes to the session.
Here, we're using the callback implementation
to transfer a news article from the sender
and handling the transfer on the receiving device.
Sessions are not just for transferring
an experience between devices, but also sharing state
across the sender and all receiving devices.
Within shared sessions, we refer to the sending device
as the primary participant and all
receiving devices as secondary participants.
Creating a shared session is the same other than providing
an implementation of primary session state callback
and calling our sessions inviteToSession
method rather than transferSession.
In this example, we're supporting a group food order.
PrimarySessionStateCallback implementation
has callbacks for the individual state change operations where
you can implement custom logic.
Secondary participants can use the established session
to both receive and send state to and from
the primary participant.
Secondary participants have an implementation
of SecondarySessionStateCallback to handle session state
changes.
We are delivering our multi-device APIs
through a new open-source SDK backed
by new platform capabilities.
While we're working to bring those capabilities to AOSP,
we are initially distributing them via Play services
to support our ubiquity goals with support back to API 26.
Optimizing battery life and providing secure and seamless
experiences are critical to both Google and our users.
To further these goals, we are taking advantage of innovations
in the underlying hardware, including SOC offload modules
on devices using Snapdragon for a low-power offload
architecture that enables faster discovery and connections.
Besides offload modules provided by SOCs,
the architecture includes CHRE Nanoapps, standardized APIs,
and a new Open OTA protocol.
This is still under development, and we will share more details
as progress is made.
Our initial release of the multi-device APIs
will be a developer preview that will iteratively
expand to additional form factors and platforms.
Once Play services support is available,
we will also provide our SDK in a fun sample app.
As part of the developer preview,
we're eager to get your feedback and learn
about additional opportunities where we can simplify
your developer experience.
To learn more about our overall efforts
to provide powerful ways for you to create
compelling multi-device experiences, please
visit our new microsite.
We are really looking forward to working with all of you
to reimagine the way our shared users' devices can work better
together.
[MUSIC PLAYING]