Transcript
[ Music ]
[ Applause ]
>> All right.
Thanks very much.
So I'm excited to tell you all
about what's new in watchOS 3.
Now, of course we've
really focused in watchOS 3
on optimizing the
performance of the system,
and there's been a ton
of changes in this area
to make sure that all of your
apps run as fast as possible.
We've also spent a bunch of
time optimizing navigation,
and that's really in service
of optimizing performance,
because the faster we can
get a user into your app,
because the faster we can
get a user into your app,
the faster they can
start using it,
and the faster we can
get them to be able
to drop their wrist again,
and move on to the next thing.
Now in addition to all these
enhancements to the system,
we've also spent a bunch of
time optimizing different things
in all of our apps as well.
Now all of those
enhancements really revolve
around three key qualities for
watch apps that I promise you
and warn you you will
continue to hear a lot
about throughout the rest of
the watch sessions [laughter].
So the first one is making
sure that they're glanceable.
Now, being a glanceable
watch app does mean a bunch
of different things, and it
starts right at the watch face,
because having a complication
on the watch face gives you
a really great opportunity
to present the most important
bit of information from your app
to the user at just a glance.
Of course, in watchOS
2, we also had glances.
In watchOS 3, that functionality
has merged into the dock,
which is a great place to
present glanceable information
which is a great place to
present glanceable information
as well, because it's really
quick to get to from anywhere
on the system and gives you
an easy way to get an overview
and summary of the best and
most important information
from your apps.
So in addition to being
glanceable, we wanted all
of our apps to be actionable,
and actionable can mean a number
of different things as well.
It might mean that you take
the action on the watch itself.
You've seen that we've
redesigned a bunch
of our built-in apps
to make sure
that the most common actions
that we take are easy to access
with just a couple of taps.
The Workout app, you can
now get into really quickly
and start a workout
with a single tap.
The timer app now raises
the most common timers
that you'll want to set
right to the top level
so that once you're in it,
with just one tap you can
start really common timers.
And so this kind of
pattern is something
that we definitely would
encourage you to think about,
figure out the things that
are the most common actions
in your apps, and brings
them up to the top level,
and make them really
easy to get to.
Of course, being actionable
doesn't necessarily mean
Of course, being actionable
doesn't necessarily mean
that you have to be able to take
the action on the watch itself.
It might just mean presenting
content that your users want
to act on, even if they're
not ultimately going
to take an action on the watch.
Again, complications are
a great place to do this
and the new dock as well,
presenting the most
important information
that users can then go and act
on outside in the real world.
And then the third quality,
of course, is responsiveness,
making sure that your apps are
up to date and ready to respond
as soon as the users want them.
And a bunch of the
performance work that we've done
in watchOS 3 is really
geared towards this aspect
of making all of the apps
as responsive as possible.
By keeping them in memory,
which we'll talk a little bit
more about, and making sure
that they can resume really
fast, we can make sure
that they're as responsive
as they can be.
And the best thing that you
can do to help make sure
that your apps remain
responsive is
to do adopt the new background
app refresh technologies,
which we'll talk about in
a little bit, to make sure
that your apps already have
the content that they need
to display to the user when
they're ready to be used.
to display to the user when
they're ready to be used.
So thinking about apps,
of course, we can go back
to a full-screen view of an app.
That's what a lot
of people think
about when they first
think of an app,
but that may not be the
most common place for users
to interact with your
apps on Apple Watch,
because to keep interaction
short,
there's some other really great
interfaces that are even faster
to use for a lot of the most
common things that we do.
Of course, there's
complications, which start right
on the watch face,
giving you info you want.
And notifications,
which can pop up info
at the most relevant time.
And notifications on Apple
Watch are great, because you get
to run code to populate the
notification with content
and custom UI to present
just the interface you want.
And of course, with the new dock
in watchOS 3, you can now get
to your apps with just the
tap of the side button,
no matter where you
are in the system.
Now, apps in the doc are great,
because they're immediately
responsive.
As soon as you tap on
one, it comes full-screen,
As soon as you tap on
one, it comes full-screen,
and you can interact
with it right away
without having to wait at all.
The dock is great, not just for
directly interacting with apps,
but also for consuming
information.
Glances in watchOS 2, that
functionality has now moved
into the dock in watchOS
3, so you can quickly slide
through a view of
the information
from your favorite
apps really quickly
to get a high-level overview of
the info from all of those apps.
So the dock combines the best
of what glance has provided
with quick access to your apps
to provide even more
functionality.
So for something like reminders,
it's really great for both.
You can get a quick overview of
the things that you need to do,
and you can tap in to
immediately bring it full screen
and make it interactive,
so you can check them off.
For other kinds of apps, you
may just have functionality.
For example, the Workout app,
we've brought those most
common workouts that you want
to perform right to the top
level, so you can tap on them,
tap in to bring the app full
screen, and with one tap,
be starting your workouts.
But the dock is also,
as we said,
great for just viewing
information.
So an app like the
Activity app is really great
for just getting a summary of
the information from this app.
And with the Activity
rings basically taking
up the full screen, you can
get a great high-level summary
that's really glanceable
and really easy to digest.
The Activity app itself has
also been redesigned when you go
into it to simplify the
navigation in the app.
So where in watchOS 2 it was
four tabs arranged horizontally,
each of which could scroll
vertically, in watchOS 3,
there's just one view,
vertically scrolling,
that has the summary of
the activity at the top
and some of the detail below.
So it's really easy
and even faster
to get the information
you want out of this app.
Now, we want to keep
interactions with the watch
as short as possible, and
so this new navigation model
and the enhancements
to make apps responsive
and live right away
really helped to make sure
that the most tasks
that you want to perform
on Apple Watch can
be accomplished
in just a couple of seconds.
And so as you're thinking about
how you want to update your app
for Apple Watch, for watchOS
3, or if you don't have one yet
and you're contemplating
what to put in it,
I would definitely
encourage you to spend a bunch
of time thinking about how
to shorten your interactions.
Two seconds is obviously a
very short time, but striving
for that can really help
you to figure out the best
to design your apps to make
them as great an experience
on Apple Watch as possible.
So with the rest of our time, I
want to talk about four things.
The first is Background
App Refresh.
As I mentioned, this is a
huge enhancement in watchOS 3
that is Background App
Refresh that is really critical
for building responsive
watch apps, so we're going
to spend a bunch of
time talking about that.
Then I also wanted
to talk a little bit
about simplifying navigation,
because we've done a lot of work
to simplify navigation
on the system,
but the next step is
simplifying navigation
within your apps as well.
And so we've got some ideas of
how we've done that ourselves
And so we've got some ideas of
how we've done that ourselves
that we'll share, and
there's also plenty of ways
that I'm sure you can come up
with to simplify navigation
in your own apps as well.
Then we'll spend
some time talking
about expanding API
availability.
We've brought some
great frameworks
from our platforms,
the watch SDK.
We've got some brand new ones,
and we've got some
great enhancements
to our existing frameworks
as well, so we'll talk
about a bunch of the
high-level points in there
and give you some great
pointers to other sessions
that have even more detail.
And then we'll end by
talking about discoverability
and configuration, because
building your great app is just
the first step.
You also need to get
it in front of users
and configure it on their watch.
So let's get started with
Background App Refresh.
Background App Refresh
is a critical part
of building a responsive
app for Apple Watch.
And before you've
even done any work,
Background App Refresh is
already working for you.
You don't actually
need to adopt any APIs
to get some of its benefits.
So the first thing is that all
of the users favorite
apps are kept in memory.
of the users favorite
apps are kept in memory.
They're launched in the
background, and then suspended,
and kept there ready to go so
that as soon as the user wants
to get them, it's just a short
resume away, and we don't have
to wait for a full
application launch.
Now, I mentioned
that that applies
to the user's favorite apps,
and I do mean something
pretty specific by that.
This is all of the apps that are
on the user's current watch
face, so any complication
on the current watch
face that has an app,
that app is one of
their favorites.
And all of the apps
that the user has placed
in their dock are
their favorite apps.
These apps are the ones that
they're kept in memory and ready
to go as soon as they're needed.
They're the ones that the user
has the easiest access to,
because they're either a
tap away on the watch face
or just an easy scroll
through the dock away.
And so we want them to
be there, ready to go,
and as responsive as possible.
And as I mentioned, you don't
have to do anything to get this.
Even your existing watchOS
2 apps will get this
behavior automatically.
But of course, there
are APIs involved
with Background App
Refresh that you can adopt
to make your apps even more
responsive once they become
to make your apps even more
responsive once they become
to the foreground and
making sure that they're
up to date and ready to go.
And so the first
things that you can do
with this are obviously
updating your complication
and updating your app.
Keeping your app up to date
means updating these things.
But there's another
important aspect to it as well
that might be immediately
obvious,
and that is that you want to
also update your snapshot.
Now you might be wondering
what do I mean by a snapshot,
because you haven't
written code for snapshots.
And this applies specifically
to apps that are in the dock.
Now, when the dock first
comes to the foreground,
all of the apps that are in
the dock are sitting in memory,
but they're suspended and
not currently running.
So what's displayed as soon
as the dock comes forward is a
snapshot of what the app looked
like in its last state.
Once the user settles on
one of the apps in the dock,
it will be resumed
and become live,
even while it's still
shrunk down in the dock.
But in the meantime, we're
displaying a snapshot
of what was there
in the last state.
So it's important that that
snapshot remain up to date
So it's important that that
snapshot remain up to date
as well, so that you're
displaying old information
until the app gets resumed.
Even more importantly, if I
quickly scroll through the dock
and don't land on
any of the apps,
they're not being unsuspended
and resumed the entire
time while I'm scrolling.
So we're just scrolling
through the set
of the last snapshots
that were displayed.
So you definitely want to make
sure that these snapshots are
up to date and displaying
current information,
and the Background App Refresh
APIs make it really easy
to do this.
Starting off, there's actually
some automatic behaviors
that you get from the
system before you even have
to add any new requests
to update things.
Now, the first one is
probably pretty obvious.
If you've actually gone
into the app and used it,
then the user has probably
seen some new information
or performed some action
in there and will want
to update the snapshot that
will be displayed the next time.
So when the user
leaves your app,
the system will automatically
schedule a snapshot update
to happen on your behalf.
Now, it's really
easy to handle this,
because there's one new
Background App Refresh method
that all of the background
refresh activity goes through.
So it's just a simple
method that you add
on your WatchKit
extension delegate,
and it'll get called
back when any
of these refresh
activities occur.
And so the first one is the
automatic snapshot that happens
when your app is suspended.
But there's also other times
that users may see information
from your app, where you'll want
to update the snapshot so often
that we just do it
automatically.
And the other one, which
may not be as obvious,
is after a notification
has been viewed.
So if the user looks at a long
look of your notification,
they may have seen some new
information that informs them
of some new state in your app.
If they then go into the dock
and see something else displayed
there and it's out of date,
that would probably
be surprising.
So when your notification
is dismissed,
the system will automatically
schedule a background snapshot
task for you in that
case as well
so that you can update
your snapshot,
update your complication, and
make sure that everything stays
up to date and in sync.
Of course, there are also
times that you'll want
to schedule updates
on your behalf.
to schedule updates
on your behalf.
You know your users and you know
your data, so there are times
where you actually just want
to proactively be
updating your content,
and there's really
two ways to do this.
The first is going to
be about complications.
The question then becomes, what
do you put in your snapshot?
So the first and most
obvious thing to put
in your snapshot is just
whatever the content
of your app normally is,
that way it looks up to date
and it's showing exactly
what you would want
when a user goes into the app.
But you might also
decide that you want
to provide some custom
information that is different
so that it looks nicer
in the dock and is easier
to glance at and digest.
For example, the Dexcom G5
mobile app, with that app,
the most important
thing that I would care
about is my current
blood glucose level.
So if I look at it in the dock,
I'll see that highlighted really
big in the center of the screen.
But when I actually go
into the app, I might care
about more detail than
just the current reading.
So as I bring the app full
screen, it can transition
and show more information
when I'm actually in the app,
and show more information
when I'm actually in the app,
displaying, in this
case, a historical graph
of more information
going back in time.
Now, you don't necessarily have
to display different information
in the dock snapshot, and a
very common thing would be
to not do that, and just have
it be the content of your app.
But you do have a lot
of flexibility here,
so if it makes sense in your app
to display something different
in the dock snapshot, just
make sure that the transition
as you go into the
app is still smooth
and not really jarring
when it happens.
Okay, so in addition to these
automatic snapshot tasks
and keeping your snapshot up
to date, you may also want
to periodically be able to
update the data behind your app
in the background, and
there's a few different ways
that you would go
about doing that.
Now, you might just
be interested in going
out to the Internet to fetch
some new data, and you can do
that with a NSURLSession
and Watch Connectivity,
but there's plenty of other
ways as well, and the first one
to focus on is complication
updates.
Now, complications are visible
right on the watch face,
so it's even more
important that they stay
so it's even more
important that they stay
as up to date as possible.
So there's a kind of update
that is available just to apps
that are on the current
watch face,
and that's the silent
complication push update.
Now, these types of updates
existed in watchOS 2,
but they were a little
bit difficult to use,
because you couldn't
be guaranteed
of how many you would get
over the course of the day,
so it was a little difficult to
plan for how many you would use
and when you would send them.
In watchOS 3, there's
been a big enhancement
for complication push
updates, and we now guarantee
that over the course of the day,
each app on the watch face
can get 50 push updates.
This is great, because it gives
you the opportunity to plan
for how you want to use them
over the course of the day.
So for example, let's
say we took a stocks app.
If we just did the
most naïve thing
and distributed our 50
updates over the full day,
that would give us about
one every 30 minutes.
And that's not too bad, but we
could do a lot better if we took
into account a little bit
information about the data
that we were displaying and
about our user behavior.
For example, let's
say that we know
that our user generally sleeps
between midnight and 6:00 a.m.
If that's the case, then
we really don't need
to update during
that period of time,
and we can distribute the
updates we would have used then
through the rest of the day.
So that'll increase
our update frequency
to once every 20 minutes, which
is a pretty big improvement
with only a small
amount of effort.
But of course, it we
know a little bit more
about the data itself and
could take that into account,
then we might be able to
do even better than that.
So let's say that we knew
that our stocks were only
from the New York
Stock Exchange.
In that case, we'd only need
to update between 9:00 a.m.
and 4:00 p.m. when
the exchange is open,
and that would increase
our frequency
to once every eight-and-a-half
minutes.
So now, obviously, this
specific example will not apply
to the vast majority of
your apps, but the idea
in general definitely can.
Taking into account a little
bit of extra information
that you have about your user
behavior and the kinds of data
that you're displaying can
give you a lot of opportunity
that you're displaying can
give you a lot of opportunity
to even further enhance
the experience
when using your app
on the watch face.
Okay, but those are just
for complications displayed
on the current watch face.
Now, if you have an
app that's either not
on the current watch
face but in the dock,
or an app on the
current watch face
where push updates maybe
don't make the most sense.
There are other ways to
update your data as well.
In these cases, you'll
probably want
to do some periodic scheduled
updates in the background
over the course of the day.
So there's another
Background App Refresh API
that will let you schedule
the next time that you'd
like to run, and each time
you run, there's a number
of different things that
you could choose to do.
You could start some data
downloads using NSURLSession
or Watch Connectivity.
Or you could just load new
data out of your database
on the watch if you already have
all the information present.
But in addition to that,
you'll also have the ability
to schedule the next
update session.
So it's not a fixed period that
you have to decide on upfront.
So it's not a fixed period that
you have to decide on upfront.
Each time you run, you
have the opportunity
to choose the next best
time to run after it
so that you can optimize
for your data style
and when you know that
it will be updated.
Now, at a minimum,
you'll be guaranteed
that your application can
run at least once an hour,
but there are some other
things can enable you
to run even more
frequently than that.
So the first would be if
your application is backed
by a complication.
So if a complication is
on the current watch face,
then your app will
have the ability
to update more frequently
than once an hour.
But even if you're not on
the current watch face,
you may be able to run more
frequently than this as well.
So the total number of updates
that are available is fixed
for all of the apps that
are currently in the dock.
So if the dock is full, and
all ten apps are present,
then each of the apps
in there will be able
to update once an hour.
But if the user hasn't
filled their dock,
and there are fewer
apps in there,
the updates that would have been
given to the ones that aren't
in use can be distributed
amongst the rest.
in use can be distributed
amongst the rest.
So in that case, you
could end up having more
than one update per hour.
Of course, as you're designed
your app, it's probably easiest
to plan for once an hour,
because that's the
minimum guarantee.
But just keep in mind
that it may be possible
that you could be running
more frequently than that,
depending on these
other situations.
So there's one last thing
that I wanted to mention
about complication pushes.
Complication pushes, when you
think of a push, the first thing
that may come to mind is a push
that's initiated from a server,
and that's definitely
one option.
You can start a complication
silent push update
from the server.
But what you may not
have thought of is
that you can also start
complication pushes
from your iPhone app running
on your iPhone as well.
The push update API
is actually part
of the Watch Connectivity
framework.
So if your app on your iPhone is
running for some other reason,
either the user is
directly using it
or it's using some Background
App Refresh API on the phone,
it can initiate a complication
push update to the watch
it can initiate a complication
push update to the watch
to update the UI on
your complication.
So even if you don't
have a server
that has the knowledge
necessary to do pushing,
you may actually still be
able to take advantage of this
to keep your watch
face up to date.
So just something
to keep in mind
as you're designing
your complications
and your refresh
strategies for your apps.
So that's just a quick summary
of Background App Refresh
and how all this stuff works,
and I really want to reemphasize
that it's really a critical part
of building responsive apps.
So no matter what kind of app
it is that you're building
for Apple Watch, I'd strongly
encourage you to check
out the Keeping Your Watch Up
to Date session to learn more
about Background App Refresh
and how you can use it
to keep your apps live,
responsive, and up to date.
So next, let's talk about
navigation enhancements.
Now, as I've mentioned, we've
already done a whole bunch
of work to optimize navigation
on Apple Watch itself.
So the system is already really
fast to get into your apps.
The next step is optimizing
navigation within your apps
The next step is optimizing
navigation within your apps
so that it's really fast
to get to the information
and actions that the users want.
Now, there's one common
pattern in particular
that I want to start with.
There's many apps that have
a hierarchical organization
to their data.
For example, there's a
top-level view that has a bunch
of information on a
list of top-level items.
In this case, I've written
an app to keep track of all
of the beverages that
I've consumed today.
Now, if you want information
on any one particular item,
you can tap on it, and it'll
slide into a detail page.
So here we can see that
I've had three cups
of coffee so far today.
In watchOS 2, if you wanted to
get more information about one
of those other items, you
would tap the Back button,
find the other item,
and slide into that one.
Now, that may not seem
like a lot of overhead,
but given how short we're trying
to keep these interactions,
that additional time
just moving back
and forth can actually
really add up pretty quickly.
So in watchOS 3, you'll find
that there's a lot of apps
So in watchOS 3, you'll find
that there's a lot of apps
that have this kind of
pattern, where we've now moved
to a new style of
navigation for them,
where you can just use your
finger or the digital crown
to quickly scroll and page
between each of those items
without having to do the back
and forth navigation transition.
So if you look at, for
example, the Stocks app
or the Weather app,
they've been redesigned
to enable this ok
interaction, and we wanted
to make it really easy for you
to adopt this in
your apps as well.
So the WatchKit table interface
control now has an option
to enable this vertical paging
mode when you're navigated
into a detail view, and it's
really easy to opt into it.
There's just a couple of
things you have to do.
First, obviously you can enable
the option on your table.
But then you also
have to make sure
that in your storyboard
you're using segues
to represent the
transitions from your table
into the detail views.
By doing that, you give WatchKit
all the information it needs
to be able to pre-generate
the views above and below,
and place them in a
vertical paging interface
so that it can move
between them.
so that it can move
between them.
So not too much adoption,
and it's really easy.
The only other thing to keep in
mind is that to get the behavior
to match this, you also need
to make sure that the design
of your detail views
fits all the content
of the detail view
onto a single screen.
If the actual detail view
itself is also scrollable,
then that scrolling in the
detail view will take precedence
over the outer paging interface.
So you definitely want to focus
on simplifying the views
for the detail items.
You'll find, again, in the
Stocks and Weather apps
that these views now, while
in watchOS 2 they scrolled
vertically and had a bunch
of information in them, are now
just single-page interfaces,
so that they can easily
transition like this.
Okay, so we've gotten our
users into our app really fast.
We've optimized the background
refresh so that our data is
up to date, and we've
optimized navigation
within our app as well.
The last part of ensuring
that individual interactions
with Apple Watch are short
is to get our users back
with Apple Watch are short
is to get our users back
out of our app as
quickly as we can.
And of course, on Apple Watch,
that means giving
them the confidence
that they can drop their wrists.
So there's a number of ways that
you might go about doing this.
Let's just take one
example here.
Let's say that I've got an app
where I'm purchasing my dinner.
When I tap this Buy
button, I'm going to go
and do some network activity
to a server, which is going
to perform some actions
to decide whether
or not I can actually
make this purchase.
Now, that might take a while.
So my first inclination might be
to display an indeterminate
progress indicator to the user,
letting them know that
something's happening,
but I'm not sure how
long it's going to take.
Now, unfortunately, that means
that they're going to sit there
with their arm up, waiting
for something to happen
until this task finishes.
But if I'm really confident
that the vast majority
of the time the task
is going to succeed,
I'm not actually
getting anything
by having them sit
there and wait for it.
So instead, you could decide
that you could present
some confirmation interface
that really gives
them the confidence
that you're taking care
of the task without having
to wait for it to occur.
So in this case, I've
just said, "Got it!
We're working on your order."
Once they read that, they have
the confidence they can drop
their wrist, and you can
continue the operation
in the background for up
to 30 seconds using the
background activity APIs
on NSProcessInfo.
Generally, everything
works, and so you don't have
to get their attention back.
Now, of course, sometimes
something may go wrong.
Maybe your server's
not reachable,
or there's some other issue.
In that case, watchOS 3 includes
a brand new User Notification
framework that lets you
schedule local notifications
on the watch itself,
and that's a great way,
during this background
time to be able
to get the user's
attention back,
let them know something went
wrong, and have them be able
to fix it really easily.
So in this case, let's
say that, unfortunately,
my order of chicken
was not available.
I can pop up a notification,
letting them know that happened.
Of course, because notifications
can include actions,
I can have some buttons
right there with options
I can have some buttons
right there with options
to resolve the issue, or I
can get them quickly back
into my app so that they can fix
it themselves in the full app.
The User Notification framework
is a great way to do this,
but of course, it's not just for
letting users know about issues.
Local notifications can
be a great enhancement
for many different
kinds of apps.
And the great thing about the
User Notification framework
in watchOS 3 is that it can work
when the watch is
entirely standalone,
because it's scheduling
the notifications
on the watch itself.
But now you do have a choice
to make with notifications,
because you can either use the
notification framework directly
on the watch to schedule
your notifications,
or you can continue doing what
you were doing in watchOS 2,
sending a message
back to your phone app
with Watch Connectivity and
scheduling a notification there.
These are actually both
totally valid things to do,
and it depends a little bit
on what you're trying
to accomplish.
The important distinction is
where the notifications
will appear.
So if you send a message
back to your phone app
with Watch Connectivity, and
schedule the notification there,
the notification will appear on
both your phone and your watch,
and you'll be notified on
whichever device you're using.
and you'll be notified on
whichever device you're using.
So if you were using your
phone, it would appear there.
If you're using your watch,
it would notify you there.
If you use the new User
Notification framework
on the watch itself, that
notification will only appear
on the watch and will not
propagate back to the phone.
Now, that actually might
be exactly what you want.
There are many cases
where you really do want
to schedule a notification
that would only ever show
up on the watch at all, and
that's now easy and possible
with the new User
Notification framework.
But even better is
you-- [clapping].
Thanks. But even better,
you don't necessarily
have to make the choice.
If your goal is that you want
the notification to appear
in the right spot,
no matter what,
even if the user leaves their
phone behind, you could choose
to schedule it in both places
using Watch Connectivity
to send a message
back to your phone app
and scheduling it there, or
maybe it was just data that was
in your cloud service,
so you just,
by default, schedule it there.
And also scheduling it with the
new User Notification framework
on the watch.
If you do that, as long
as you've used the same
notification identifier both
times that you schedule it,
watchOS will de-duplicate
those notifications
so that you only have it appear
on the watch once, not twice.
So some great new stuff with
the User Notification framework.
Now, while individual
interactions
with the watch are short, there
may be some apps that you want
to use multiple times
over a longer period.
For example, here I've got
my chicken pot pie recipe,
and I'm going to
the store to pick
up all the items
I need to cook it.
Now, in watchOS 3, each time I
raise my wrist, I'm brought back
to the last app that I was used
to that I can really quickly
see the items that I still need
to pick up, and check off the
ones that I've already gotten.
I'll be brought back
to that last app for up
to eight minutes
after I last used it.
This is great, because
it lets you design apps
that have this kind of
interaction pattern,
where you use it for
many brief interactions,
but over a longer
period of time.
but over a longer
period of time.
This is the new user default
for all users in watchOS 3,
so it's to plan for this
and build your apps
and design around it.
These are just a few of the
ways that we've been thinking
about improving app
interactions in watchOS 3,
and there's a ton of other ways.
I'd encourage you to check out
the Quick Interaction Techniques
for watchOS session, where you
can get more detail on a bunch
of these kinds of ideas and
a bunch of others as well.
So that's navigation.
Now let's talk a little bit more
about the enhanced API
availability in watchOS 3.
As I mentioned earlier,
we've brought a bunch
of great frameworks from
some of our other platforms.
We've got some great
new frameworks.
For example, the User
Notification framework,
and we've also added a
whole bunch of APIs to many
of the frameworks that are
already on Apple Watch.
So let's start with one
we've already talked about,
Background App Refresh.
I wanted to bring
it up again just
to reinforce how important
I feel like this stuff is.
And the three key things that
it gives you are the ability
to schedule updates, perform
complication push updates
with that guarantee of 50
over the course of the day,
and make sure that your snapshot
and your doc is up to date
and in sync with
your notifications
and your complications.
Again, definitely check out
the Keeping Your Watch App
Up to Date session as well for
far more information about this.
Now, fitness apps have a unique
need for staying up to date,
because during a workout
it's really important
that they be displaying
current information and up
to date throughout the workout.
So the big enhancement for
workout apps this year is that,
in watchOS 3, they will continue
to run in the background
for the entire duration
of your workout session.
This gives you the opportunity
to monitor workout progress,
watch-- use all of the
sensor API to keep track
of where things are going,
and notify the user
using notifications,
and notify the user
using notifications,
or haptics, or sounds.
And of course, we've enhanced
the access to the heart rate
and accelerometer so they
now provide continuous values
throughout the entire workout,
instead of batching those values
in increments that are
delivered in chunks.
So it makes it really easy to
keep track of the current state
of the workout the entire
time and stay up to date.
Because they're running,
you can also update your UI,
which makes sure that as
the user raises their wrist,
they can very quickly see
the correct current state
of the workout without
any extra delays.
It's a really, really big year,
actually, for fitness apps,
and there's an entire session
just about these and a number
of other enhancements for
these apps, so definitely check
out Building Great Workout
Apps to learn all about how
to make your workout apps
really amazing in watchOS 3.
But there is one
bit I want to focus
on a little bit more here first,
and that's the background
runtime.
Because there's a bit of
a balance to be had here,
you absolutely want
to have your app
up to date during the workout.
But you also want to make sure
that you're preserving
a great experience
for users throughout the rest
of their day by being careful
to preserve their battery life.
And a big components
of that is making sure
that you're keeping track
of the amount of CPU
that you're using
during the workout.
And Xcode now has a great
interface to help you keep track
of that, both how much
you're using at an instant
and the amount that
you're using in aggregate
over a period of time.
So for the first part,
there's a clear view,
right up here near the top, that
will tell you the amount of CPU
that you're currently using,
and then down in the center,
there's a great graph that shows
you some historical information
about the CPU usage over time.
Now, you can clearly
see here the spikes,
where we've been
doing a bunch of work.
But in yellow, in
the center there,
you can see that we've got a
rolling average of the amount
of CPU that's being consumed
by our app in the background
over some period of time.
Now this part is the
one I want to focus on,
and it's the most important,
because while your workout app
is running in the background,
because while your workout app
is running in the background,
there's a cap imposed
on the total amount
of average CPU usage
that it can be using
over this period of time.
And you want to stay below
that cap to make sure
that your app continues
to run in the background,
and preserves the
battery life of the user
over the whole rest of the day.
So that cap here is
indicated clearly by Xcode
by the red dotted
line, and you can watch
as your average approaches
it, and make sure
that you stay below it.
So there's, again,
a ton of information
about the background
fitness workout experience,
improvements.
Definitely go check out more of
that, but this is the one thing
that you really should keep
in mind about CPU usage
as you're developing these apps.
So in addition to the sensor
enhancements for these kinds
of apps with making heart rate
and accelerometer
continuously available,
we've also got a bunch of
great new hardware access APIs.
So crown events give you raw
access to rotation events
from the digital crown.
In watchOS 2, your apps could
use the crown for scrolling
within your interface or for
picking items from a list
within your interface or for
picking items from a list
with the picker control.
But of course, we saw
many innovative uses
of the picker control for
other interesting things,
and we realize that everybody,
obviously, wants raw access
to digital crown events.
So that's now available, and
you can use it for all kinds
of other interactions
in your apps as well.
Now--
[ Applause ]
Now just gesture recognizers
really make it easy
to add touch interactions
to your apps.
There's a whole bunch
of single-finger interactions
available, like tap, swipe, pan,
long-press, and it's really
easy to add these to all
of your different
WatchKit interface elements
so that you can have
different parts
of your app screen
respond in different ways.
And of course, we've also made
the gyroscope accessible now
in addition to the
accelerometer,
so you've got a ton of
information about the motion
of the device available for all
kinds of interesting use cases.
Again, the quick-- oop.
Go for it [clapping].
Again, the quick interaction
technique session has a bunch
of information on this
and other use cases.
I do want to give you a
couple examples of some
of the cool things that you
can do with this though.
So first off, you can see here
Acorns has made use of the crown
to let you quickly scrub
through information
on a graph showing you
the historical information
about your account.
So in a single simple
interface, you can quickly move
through a lot of information,
all visible on one screen.
Here we have Sweat with Kayla,
which has taken advantage
of the swipe gestures to
be able to quickly move
between these different workouts
and choose just the
one that they want.
Of course, you can also use
the digital crown to move
between them, and with just a
tap, you can activate the one
that you're interested in.
Now you'll notice
that there's some kind
of interesting visuals here
that are adding a little
liveliness to the interface.
And to help make that
possible in all your apps,
we've got some great
graphics and media frameworks
that we've bought
over to Apple Watch.
that we've bought
over to Apple Watch.
SpriteKit and SceneKit make
it really easy to add both 2D
and 3D graphics and animations
to enhance different
parts of your apps.
And of course you can use them
in your long look
notifications interfaces as well
to make your notifications
really interesting and lively.
And because we've
been talking a lot
about simplifying navigation, we
also wanted to make it possible
to play back video in line
in your application
interfaces as well.
In watchOS 2, we introduced
video playback in watchOS apps,
but for it to work there,
it actually took you
out into a separate
full-screen interface,
where you watched a video
and then dismissed it
when you were done.
With inline video
playback, you don't have
to leave your application's
primary interface at all,
and you can play it
back right there.
Even better, it supports
autoplay,
so as soon as the video
becomes visible on screen,
it will start playing and
can pause when it goes off.
If you have multiple short
videos on a scrolling list,
the one on screen at any one
time will automatically play
while all the others pause.
It's a really great way
to add some really
short interaction videos
to add some really
short interaction videos
into your apps.
And because apps in the dock are
live while they're in the dock,
the autoplay feature can
actually even work there.
So if you have a quick video
that needs to be displayed
as you scroll through the
dock, when users come to rest
on your app, that video can
start playing right in line
without even taking
your app full screen.
So some really great
enhancements
for video in watchOS 3.
SpriteKit and SceneKit can be
used for all kinds of things.
Here you can see a Seven
Minute Workout has taken great
advantage of SceneKit to bring a
lot of the visuals that they had
on their iPhone app to
Apple Watch as well.
So you can see exactly the
workout that you want to perform
and get a lot of clarity
on how you should do it.
So in addition to adding a
lot of interesting visuals
to your apps, SpriteKit and
SceneKit are obviously great
for short interaction games.
We've also bought GameKit to
Apple Watch and watchOS 3,
which makes it really
easy for you
to add turn-based gaming
to your watch apps.
Because GameKit's turn-based
gaming APIs are built on top
Because GameKit's turn-based
gaming APIs are built on top
of NSURLSession,
they can work even
if your phone is not present,
when your watch is near
known WiFi networks.
The GameKit achievement
APIs can also be used
to earn achievements on Apple
Watch, which can then be viewed
on iPhone, or iPad, or
your other platforms
where you've got your game.
And of course, with AV
foundation, it's not really easy
to play sounds out
of the watch speaker.
Now, gaming on Apple Watch is
really just getting started,
and with some of these new
frameworks, I'm really excited
to see what kinds of
things you guys come up with
for short interaction
games on the watch.
To give you just one idea
of how this can result
in a really interesting game,
I want to show you a quick
video here of a new game
that WoGa is developing
called Fish Time
that lets us go fishing at
short intervals on our watch.
So with just a swipe,
I can go cast my line,
and I can use the digital
crown to drop my lure
down to just the right
depth where I want.
Now, I could leave it there for
a while and wait, or I can tap
Now, I could leave it there for
a while and wait, or I can tap
to go fishing right now.
Looks like I got a bite.
Now you can use the crown
again to reel it in,
but now I actually--
I didn't catch it.
That'll probably make the
fish a little happier,
although our fisherman might
not be so happy about it.
So really cool how you can add
some really interesting graphics
and get some great animations
using SpriteKit on Apple Watch.
Really, really looking
forward to see what kinds
of things you guys do with this.
So next up, I want
to mention CloudKit.
We've brought CloudKit
to the watchOS SDK,
including the new CK Share
APIs, which make it really easy
to share data between
different users.
Again, because it's built on an
NSURLSession, it's really easy
for it to work, even when
your phone isn't present.
There's a whole session on
CloudKit with What's New
in CloudKit that I definitely
encourage you to check out.
And finally, we've
got Apple Pay.
Apple Watch is a great way
to pay for physical goods
Apple Watch is a great way
to pay for physical goods
in stores, and of course with
Apple Pay on Apple Watch,
you can now offer physical goods
for purchase within your apps
with just a double tap
of the side button.
Now, there's many different
ways that you might go
about using this, but for
example, you might choose
to offer for purchase the most
common item that I buy every day
for lunch, so that I can
make that order really easily
at lunchtime every day,
right from my watch.
There's a lot of ways that
you can offer physical goods
for sale within your
watch using Apple Pay.
So that's just some of the APIs
that are a part of
the watchOS 3 SDK.
There's a bunch of
new s tuff in there.
Definitely go check it all out.
I'd like to end by talking
about discoverability
and configuration,
because, again,
building a great watch app
is just the first step.
You also want to make sure
that it's really easy for users
to discover it and
get it installed.
So the first enhancement
for this comes
in the iOS 10 Apple Watch app.
There's a brand new watch face
gallery, which displays all
There's a brand new watch face
gallery, which displays all
of the watch faces that
users can add on their watch.
And even better, right
at the top of the screen,
it includes an entire
section dedicated just to all
of your apps, and getting
in here is really easy
and requires just
a couple of steps.
So first off, you have to
adopt a new ClockKit API.
You already had an
API in watchOS 2
for specifying a template
complication view.
This API has been in
enhanced in watchOS 3
to not just return a string
for your complication data,
but actually the
localization key
to get localized strings
for all languages.
This is important,
because the second step is
to build a complication bundle.
You use the-- you do
this using the simulator.
You run your app, and build
a complication bundle,
and this creates a
static representation
of your complication template
that you can then include
in your iPhone app.
It's really easy to
do, and by doing it,
it gets you into this gallery
section so that you can show up.
We need the static
representation,
We need the static
representation,
because that way we can display
your complication in line
in a watch face here,
even if your app isn't
yet installed on the watch.
So just a couple of steps,
and the payoff is really big.
You'll be right here
in the gallery.
The gallery is the first thing
that new watch owners see
after they've paired, so
it's definitely a place
that you'll want to be.
In addition to the gallery,
we've also made it a lot easier
to customize watch faces
and get your apps onto them.
It was always possible to
configure your watch faces
on the Apple Watch, and in
iOS 10, the Apple Watch app
on iPhone now includes an entire
face configuration UI as well.
Obviously, they're kept in
sync, so any changes you make
in one will be reflected in the
other, and it's not really easy
on your phone to select all
the complications that you'd
like on all your watch
faces on Apple Watch.
And with quick watch
face switching,
there's now even more reason
to have a complication,
because more users will
have more watch faces,
and your apps can
be right on them.
So then the last part of
configuration is the dock,
So then the last part of
configuration is the dock,
and obviously, you
can configure the dock
in the Apple Watch
app on your iPhone.
It's really easy to add and
remove apps from the dock,
and reorder them right there.
But even more importantly, you
can do it on the watch itself.
And there's one feature
in particular
that makes it really
easy to find
that you can add
apps into the dock.
The last app that you used is
always displayed in the dock,
even if you hadn't
chosen to put it there.
So if a user installs your
app and doesn't even yet know
that they can add
things to the dock,
they go to the home screen, they
find the icon and launch it.
The next time they go to the
dock, they'll see your app
in there with a big button
under it that says Keep In Dock,
which, with one tab, will add it
to their permanent list
of apps in the dock.
So it's really easy to discover
that you can add them there,
and also easy to add them
there from the watch itself.
So again, you're going to hear
a lot about building glanceable,
actionable, and responsive apps,
and I really do encourage
you to keep that in mind.
There's a great design
session that Michael gave
There's a great design
session that Michael gave
that you can go check out for
Designing Great Apple Watch
Experiences, where
he'll talk even more
about all these things, so
definitely check that out.
And the responsive part
of this is so important
that there are really two
sessions focused just on this,
with Architecting for
Performance on watchOS 3,
and Keeping Your
Watch App Up to Date.
These are two that you'll
definitely want to check
out to get all the benefits
of Background App Refresh
and making sure that
your apps are up to date
and responsive for watchOS 3.
And there's a whole bunch
of other sessions throughout
the week that have a lot
of information, many focused on
Apple Watch, and a whole bunch
that just include Apple
Watch information.
Thanks so much for coming
and joining, and I can't wait
to see what you do
with Apple Watch.
Enjoy the rest of the week.
[ Applause ]