TIMOTHY JORDAN: Hi, my name is Timothy Jordan.
I'm a developer advocate here at Google,
and I'd like to give you a quick introduction to Android Wear.
Android Wear is a set of APIs that extends the Android
platform to a new generation of wearables.
Rich notifications can appear on the wearable,
with no modification to the existing Android app.
The developer can add just a few more lines of code
to extend the wearable experience
or go even deeper, by building an app just for the wearable.
Before we dive into the details of the platform,
let's take a step back.
What's wrong with this picture?
We spent some time looking at technology usage
and thought deeply about the ways
to help you stay more connected to the digital world.
But also more engaged with what's happening around you.
Android Wear looks to address this
by showing you useful information the moment you
need it, and just in a glance.
Let's look at that in a more technical way.
This is your day with your phone.
Notice the length of time it takes
to pull out your phone from your pocket,
unlock it, navigate to what you want, and then engage with it.
There's a hefty time and attention cost,
even for interactions that should only require a moment.
This is the same set of interactions on a wearable.
Notice the reduced overhead per interaction.
Now this is what we mean by more present in the real world,
and yet more connected to the virtual world.
What does this mean for your development?
Well, to start with, and this is important,
it's a fundamentally different user interaction model.
And you can tell just by looking at this device.
It's a fundamentally different device
from other mobile devices.
To really nail the user experience,
you've got to rethink it a little.
When considering which features of your service
you'd like to make available on the wrist,
consider this question.
What couldn't we do on the phone that we can now
do on the wrist?
What now becomes possible with the user?
And then focus on that.
Also, you've got to try it.
It may sound silly, but once you get that emulator up
and running, stand up at your desk
and pretend you're walking between meetings
or across the street.
Something to get yourself in the situation,
so you know what it feels like to use the service on the go.
Here's an example of what we mean
by a very basic but essential difference.
This is the app experience on your phone.
Now we've trained users to collect these shiny objects,
and then search for them when they
want to do something, which works OK on a phone.
But if we put these same shiny objects on a wearable, well,
it just doesn't make sense.
It would be the same time consuming paradigm,
but on a device intended to reduce
those parts of the interaction.
It just doesn't make sense.
How do we get outside of this paradigm?
How do we get past this grid of icons?
This is the Android Wear interface.
It's simple, glanceable, and built around microinteractions.
The interface is divided into two primary behaviors.
The user can talk to the wearable.
You can think of these as actions.
The user might say, OK Google, and then any voice command
is available to them.
The wearable can talk to the user.
Now think of this as a context stream.
It's sort of like enhanced notifications
that matter to the user right now,
because it's the right time or place.
OK.
Let's talk about developing with Android Wear.
First, notifications.
The notifications on your phone can also
be displayed on the wearable.
And to get this done you don't have to do anything.
It just works out of the box.
Also, notifications that buzz or sound on the companion device,
such as your phone, will also buzz on the wearable.
Enhanced notifications will also show up on the wearable.
And again, to get this done you still
don't have to do anything.
It also already works out of the box.
There are a few things that you can do with your notifications,
specifically on the wearable.
And these do require a few lines of code.
Stacks allow you to bundle multiple notifications
together.
Think inbox style notifications.
Pages.
They give you the ability to show more than one glanceable
screen of information to the user for a single notification.
And yes, Pages can be combined with Stacks.
Replies.
They allow you to add actions to notifications
that the user can control with their voice,
via open-ended text input or through pre-defined text
responses.
If you want to have code running on the wearable,
you're going to have to build an app.
The SDK for apps isn't available yet.
But here's a few notes to get you
started thinking about them.
You can create custom card layouts and run activities
directly on wearables.
You can send data and actions between the phone
and a wearable with data replication
APIs and remote procedure calls.
You can gather sensor data and display it in a real-time
on Android wearables.
And you can register your app to handle
Voice Actions, like OK Google, take a note.
And that's the Android Wear platform.
Please check out more detail on our excellent documentation,
developer.android.com/wear.
I'm Timothy Jordan, and I'll see you next time.