[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
at 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 and
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 discovery 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
transfer session. 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 are 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 and 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
user's devices can work better together. [MUSIC PLAYING]
